@cniot/mdd-editor 0.3.6 → 0.3.8

package/src/ai/LocalAIDrawer.jsx

@@ -231,9 +231,388 @@ function PullDiffDetail({ diffSummary }) {
   );
 }
 
+const L4_CODE_PATTERN = /L4:([a-zA-Z0-9_-]+)/g;
+const DEFAULT_LINKED_PAGE_DETAIL_URL = '/l4/api/v1/console/get-by-code';
+const LINKED_PAGE_LOG_PREFIX = '[MDD AI Bridge][L4]';
+const LOCAL_CHANGE_SKIP_REASON = '本地已有未同步修改';
+
+const normalizeText = (value) => {
+  if (typeof value === 'string') return value;
+  if (value == null) return '';
+  return JSON.stringify(value, null, 2);
+};
+
+const logLinkedPageDebug = (...args) => {
+  if (typeof console !== 'undefined' && typeof console.info === 'function') {
+    console.info(LINKED_PAGE_LOG_PREFIX, ...args);
+  }
+};
+
+const collectL4ReferencesFromText = (text = '', source = 'script', path = '$') => {
+  const references = [];
+  const pattern = new RegExp(L4_CODE_PATTERN);
+  let match = pattern.exec(String(text));
+  while (match) {
+    references.push({
+      code: match[1],
+      source,
+      paths: [path],
+    });
+    match = pattern.exec(String(text));
+  }
+  return references;
+};
+
+const collectL4ReferencesFromJSON = (value, path = '$', references = []) => {
+  if (typeof value === 'string') {
+    references.push(...collectL4ReferencesFromText(value, 'schema', path));
+    return references;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => collectL4ReferencesFromJSON(item, `${path}[${index}]`, references));
+    return references;
+  }
+  if (value && typeof value === 'object') {
+    Object.keys(value).forEach((key) => {
+      references.push(...collectL4ReferencesFromText(key, 'schema-key', `${path}.${key}`));
+      collectL4ReferencesFromJSON(value[key], `${path}.${key}`, references);
+    });
+  }
+  return references;
+};
+
+const mergeL4References = (references = [], rootCode) => {
+  const referenceMap = new Map();
+  references.forEach((reference) => {
+    if (!reference?.code || reference.code === rootCode) return;
+    const existing = referenceMap.get(reference.code) || {
+      code: reference.code,
+      source: reference.source,
+      paths: [],
+    };
+    existing.source = existing.source === reference.source ? existing.source : 'mixed';
+    existing.paths = [...new Set([...existing.paths, ...(reference.paths || [])])];
+    referenceMap.set(reference.code, existing);
+  });
+  return [...referenceMap.values()];
+};
+
+const collectLinkedPageReferences = ({ schemaJson, scriptInfo, rootCode, extraSources = [] }) => {
+  const schemaReferences = collectL4ReferencesFromJSON(schemaJson);
+  const scriptReferences = collectL4ReferencesFromText(scriptInfo, 'script', 'mdd.script.jsx');
+  const extraReferences = extraSources.flatMap((source) =>
+    collectL4ReferencesFromText(source?.text || '', source?.source || 'extra', source?.path || '$'),
+  );
+  return mergeL4References([...schemaReferences, ...scriptReferences, ...extraReferences], rootCode);
+};
+
+const createLinkedPageExtraSources = (data = {}, prefix = 'payload') => {
+  const sourceFields = [
+    'schemaInfo',
+    'schemaJson',
+    'schema',
+    'scriptInfo',
+    'script',
+    'style',
+    'compileFile',
+    'translateInfo',
+    'serverDataHandle',
+    'metaData',
+    'sqlData',
+    'sqlDataCount',
+    'swaggerInfo',
+    'dataPermissions',
+    'pageMeta',
+    'pageIR',
+  ];
+  return sourceFields
+    .filter((fieldName) => data[fieldName] != null)
+    .map((fieldName) => ({
+      source: fieldName,
+      path: `${prefix}.${fieldName}`,
+      text: normalizeText(data[fieldName]),
+    }));
+};
+
+const enqueueLinkedPageReferences = ({ queue, referenceMap, references, parentCode, depth, rootCode, visitedCodes }) => {
+  references.forEach((reference) => {
+    if (!reference?.code || reference.code === rootCode) return;
+    const nextReference = {
+      ...reference,
+      parentCode,
+      depth,
+    };
+    const existing = referenceMap.get(reference.code);
+    if (existing) {
+      existing.source = existing.source === nextReference.source ? existing.source : 'mixed';
+      existing.paths = [...new Set([...(existing.paths || []), ...(nextReference.paths || [])])];
+      existing.parents = [...new Set([...(existing.parents || []), parentCode])];
+      existing.depth = Math.min(existing.depth || depth, depth);
+      return;
+    }
+    referenceMap.set(reference.code, {
+      ...nextReference,
+      parents: [parentCode],
+    });
+    if (!visitedCodes.has(reference.code)) {
+      queue.push(nextReference);
+    }
+  });
+};
+
+const fetchLinkedPageByCode = async (code, config = {}) => {
+  const detailUrl = config.linkedPageDetailUrl || DEFAULT_LINKED_PAGE_DETAIL_URL;
+  const separator = detailUrl.includes('?') ? '&' : '?';
+  const url = `${detailUrl}${separator}code=${encodeURIComponent(code)}`;
+  logLinkedPageDebug('fetch page detail', { code, url });
+  const response = await fetch(url, {
+    credentials: 'include',
+  });
+  const text = await response.text();
+  let result = null;
+  try {
+    result = text ? JSON.parse(text) : null;
+  } catch (error) {
+    throw new Error(`关联 L4 页面详情接口返回非 JSON：${text || response.status}`);
+  }
+
+  if (!response.ok) {
+    throw new Error(result?.errorMessage || result?.message || `关联 L4 页面详情接口请求失败：${response.status}`);
+  }
+  if (result?.success === false) {
+    throw new Error(result?.errorMessage || result?.message || result?.msg || '关联 L4 页面详情接口返回失败');
+  }
+  const pageData = result?.data || result;
+  logLinkedPageDebug('fetch page detail success', {
+    code,
+    name: pageData?.name || pageData?.pageMeta?.name,
+    hasSchemaInfo: Boolean(pageData?.schemaInfo),
+    hasScriptInfo: Boolean(pageData?.scriptInfo),
+    hasCompileFile: Boolean(pageData?.compileFile),
+  });
+  return pageData;
+};
+
+const getLinkedPageResolver = (config) => {
+  if (typeof config?.resolveLinkedPage === 'function') return config.resolveLinkedPage;
+  if (typeof window !== 'undefined' && typeof window.__MDD_AI_BRIDGE_RESOLVE_L4_PAGE === 'function') {
+    return window.__MDD_AI_BRIDGE_RESOLVE_L4_PAGE;
+  }
+  return (code) => fetchLinkedPageByCode(code, config);
+};
+
+const normalizeLinkedPagePayload = (reference, pageData) => {
+  if (!pageData) return null;
+  const schemaJson = parseSchema(pageData.schemaInfo || pageData.schemaJson || pageData.schema || '{}') || {};
+  const rawPageMeta = pageData.pageMeta || pageData.meta || {};
+  const pageMeta = {
+    ...rawPageMeta,
+    code: pageData.code || rawPageMeta.code || reference.code,
+    name: pageData.name ?? rawPageMeta.name,
+    region: pageData.region ?? rawPageMeta.region,
+    module: pageData.module ?? rawPageMeta.module,
+    moduleName: pageData.moduleName ?? rawPageMeta.moduleName,
+    status: pageData.status ?? rawPageMeta.status,
+    grade: pageData.grade ?? rawPageMeta.grade,
+    mddTemplateType: pageData.mddTemplateType ?? rawPageMeta.mddTemplateType,
+    buildType: pageData.buildType ?? rawPageMeta.buildType,
+    operateType: pageData.operateType ?? rawPageMeta.operateType,
+    gmtModified: pageData.gmtModified ?? rawPageMeta.gmtModified,
+    modifierAccount: pageData.modifierAccount ?? rawPageMeta.modifierAccount,
+    modifierName: pageData.modifierName ?? rawPageMeta.modifierName,
+  };
+  const script = pageData.scriptInfo?.script ?? pageData.scriptInfo ?? pageData.script ?? '';
+  const style = pageData.scriptInfo?.style ?? pageData.style ?? '';
+  const pageIR =
+    pageData.pageIR ||
+    buildPageIR({
+      schemaJson,
+      script,
+      style,
+      pageMeta,
+    });
+  return {
+    code: pageMeta.code,
+    pageMeta,
+    schemaInfo: normalizeText(pageData.schemaInfo || schemaJson),
+    scriptInfo: script,
+    style,
+    pageIR,
+    extraSources: createLinkedPageExtraSources(
+      {
+        ...pageData,
+        pageMeta,
+        pageIR,
+        style,
+      },
+      `linkedPage.${pageMeta.code}`,
+    ),
+    linkedReference: reference,
+  };
+};
+
+const buildLinkedPagePayload = async (payload, config) => {
+  const rootSchemaJson = parseSchema(payload.schemaInfo) || {};
+  const resolver = getLinkedPageResolver(config);
+  let rootPageData = null;
+  try {
+    logLinkedPageDebug('fetch root page detail for raw scan', { code: payload.code });
+    rootPageData = await resolver(payload.code, {
+      code: payload.code,
+      source: 'root',
+      depth: 0,
+      paths: ['root.get-by-code'],
+    });
+  } catch (error) {
+    logLinkedPageDebug('fetch root page detail failed, fallback to editor payload only', {
+      code: payload.code,
+      reason: error?.message || String(error),
+    });
+  }
+  const directReferences = collectLinkedPageReferences({
+    schemaJson: rootSchemaJson,
+    scriptInfo: payload.scriptInfo,
+    rootCode: payload.code,
+    extraSources: [
+      ...(payload.extraSources || []),
+      ...createLinkedPageExtraSources(rootPageData || {}, `rootApi.${payload.code}`),
+    ],
+  });
+  logLinkedPageDebug('scan root page', {
+    code: payload.code,
+    source: rootPageData ? 'editor payload + root get-by-code raw data' : 'editor payload only',
+    directReferences: directReferences.map((reference) => ({
+      code: reference.code,
+      source: reference.source,
+      paths: reference.paths,
+    })),
+  });
+  const queue = [];
+  const referenceMap = new Map();
+  const visitedCodes = new Set([payload.code]);
+  const linkedPages = [];
+  const failedLinkedPages = [];
+
+  enqueueLinkedPageReferences({
+    queue,
+    referenceMap,
+    references: directReferences,
+    parentCode: payload.code,
+    depth: 1,
+    rootCode: payload.code,
+    visitedCodes,
+  });
+
+  while (queue.length > 0) {
+    const currentReference = queue.shift();
+    if (!currentReference?.code || visitedCodes.has(currentReference.code)) continue;
+    visitedCodes.add(currentReference.code);
+    const latestReference = referenceMap.get(currentReference.code) || currentReference;
+
+    try {
+      logLinkedPageDebug('resolve linked page', {
+        code: currentReference.code,
+        parentCode: latestReference.parentCode,
+        depth: latestReference.depth,
+        paths: latestReference.paths,
+      });
+      const pageData = await resolver(currentReference.code, latestReference);
+      const linkedPage = normalizeLinkedPagePayload(latestReference, pageData);
+      if (!linkedPage) {
+        failedLinkedPages.push({
+          ...latestReference,
+          reason: '关联 L4 页面返回为空',
+        });
+        continue;
+      }
+
+      linkedPages.push(linkedPage);
+      const linkedPageSchemaJson = parseSchema(linkedPage.schemaInfo) || {};
+      const childReferences = collectLinkedPageReferences({
+        schemaJson: linkedPageSchemaJson,
+        scriptInfo: linkedPage.scriptInfo,
+        rootCode: payload.code,
+        extraSources: linkedPage.extraSources,
+      });
+      logLinkedPageDebug('scan child page', {
+        code: linkedPage.code,
+        depth: latestReference.depth,
+        childReferences: childReferences.map((reference) => ({
+          code: reference.code,
+          source: reference.source,
+          paths: reference.paths,
+        })),
+      });
+      enqueueLinkedPageReferences({
+        queue,
+        referenceMap,
+        references: childReferences,
+        parentCode: linkedPage.code,
+        depth: (latestReference.depth || 1) + 1,
+        rootCode: payload.code,
+        visitedCodes,
+      });
+    } catch (error) {
+      failedLinkedPages.push({
+        ...latestReference,
+        reason: error?.message || '关联 L4 页面加载失败',
+      });
+    }
+  }
+
+  const linkedPageReferences = [...referenceMap.values()];
+  const maxDepth = linkedPageReferences.reduce((depth, reference) => Math.max(depth, reference.depth || 1), 0);
+  const mergedLinkedPages = linkedPages.map((linkedPage) => ({
+    ...linkedPage,
+    linkedReference: referenceMap.get(linkedPage.code) || linkedPage.linkedReference,
+  }));
+  logLinkedPageDebug('scan complete', {
+    code: payload.code,
+    directCount: directReferences.length,
+    totalCount: linkedPageReferences.length,
+    syncedCount: mergedLinkedPages.length,
+    failedCount: failedLinkedPages.length,
+    references: linkedPageReferences.map((reference) => ({
+      code: reference.code,
+      source: reference.source,
+      depth: reference.depth,
+      paths: reference.paths,
+      parents: reference.parents,
+    })),
+    failed: failedLinkedPages,
+  });
+
+  return {
+    ...payload,
+    linkedPageReferences,
+    linkedPageScan: {
+      directCount: directReferences.length,
+      totalCount: linkedPageReferences.length,
+      maxDepth,
+    },
+    linkedPages: mergedLinkedPages,
+    failedLinkedPages,
+  };
+};
+
+const isLocalChangeSkippedPage = (page) => String(page?.reason || '').includes(LOCAL_CHANGE_SKIP_REASON);
+
+const createLinkedPushSummary = (res, fallbackDir) => ({
+  type: 'push',
+  dir: res?.dir || fallbackDir,
+  linkedPages: res?.linkedPages || {},
+});
+
+const createLinkedPullSummary = (res) => {
+  const changedPages = (res?.linkedPageDiffs || []).filter((item) => item.changed);
+  if (!changedPages.length) return '';
+  const codes = changedPages.map((item) => item.code).join('、');
+  return `检测到关联 L4 页面也存在本地修改：${codes}。当前只同步了当前页面，请分别打开这些 L4 页面执行“同步本地修改”并保存。`;
+};
+
 export default function LocalAIDrawer(props) {
   const { schema, scriptInfo, pageMeta = {}, bridgeConfig, onApply } = props;
-  const config = normalizeBridgeConfig(bridgeConfig);
+  const config = React.useMemo(() => normalizeBridgeConfig(bridgeConfig), [bridgeConfig]);
   const [baseURL, setBaseURL] = React.useState(config.baseURL || DEFAULT_BRIDGE_URL);
   const [status, setStatus] = React.useState('未连接');
   const [workspacePath, setWorkspacePath] = React.useState('');
@@ -248,24 +627,33 @@ export default function LocalAIDrawer(props) {
 
   const getPayload = React.useCallback(() => {
     const nextSchemaJson = schema?.getAllJSON?.() || {};
+    const nextPageMeta = {
+      ...pageMeta,
+      code: pageCode,
+    };
+    const nextScriptInfo = scriptInfo?.script || '';
+    const nextStyle = scriptInfo?.style || '';
+    const nextPageIR = buildPageIR({
+      schemaJson: nextSchemaJson,
+      script: nextScriptInfo,
+      style: nextStyle,
+      pageMeta: nextPageMeta,
+    });
     return {
       code: pageCode,
-      pageMeta: {
-        ...pageMeta,
-        code: pageCode,
-      },
+      pageMeta: nextPageMeta,
       schemaInfo: JSON.stringify(nextSchemaJson, null, 2),
-      scriptInfo: scriptInfo?.script || '',
-      style: scriptInfo?.style || '',
-      pageIR: buildPageIR({
-        schemaJson: nextSchemaJson,
-        script: scriptInfo?.script || '',
-        style: scriptInfo?.style || '',
-        pageMeta: {
-          ...pageMeta,
-          code: pageCode,
+      scriptInfo: nextScriptInfo,
+      style: nextStyle,
+      pageIR: nextPageIR,
+      extraSources: createLinkedPageExtraSources(
+        {
+          pageMeta: nextPageMeta,
+          pageIR: nextPageIR,
+          style: nextStyle,
         },
-      }),
+        'editorPayload',
+      ),
     };
   }, [pageCode, pageMeta, schema, scriptInfo]);
 
@@ -331,15 +719,22 @@ export default function LocalAIDrawer(props) {
     setPullError(null);
     setLastDiffSummary(null);
     try {
-      const res = await pushPage(baseURL, pageCode, getPayload());
+      const payload = await buildLinkedPagePayload(getPayload(), config);
+      const res = await pushPage(baseURL, pageCode, payload);
       setWorkspacePath(res?.dir || '');
       setBridgeInfo((prev) => ({
         ...(prev || {}),
         workspaceRoot: res?.context?.workspaceRoot || prev?.workspaceRoot,
       }));
       setStatus('已同步到本地');
-      setLastSummary(`已写入本地工作区: ${res?.dir || pageCode}`);
-      Message.success('已发送到本地 AI 工作区');
+      setLastSummary(createLinkedPushSummary(res, pageCode));
+      if (res?.linkedPages?.totalReferences > 0) {
+        Message.success(
+          `已发送到本地 AI 工作区，扫描到直接子 L4 页面 ${res.linkedPages.directCount || 0} 个，递归共 ${res.linkedPages.totalReferences} 个`,
+        );
+      } else {
+        Message.success('已发送到本地 AI 工作区');
+      }
     } catch (e) {
       Message.error(e.message || '发送到本地 AI 工作区失败');
     } finally {
@@ -364,9 +759,14 @@ export default function LocalAIDrawer(props) {
         scriptInfo: nextScriptInfo,
         raw: res,
       });
-      setLastSummary(res?.summary || '已从本地工作区同步修改');
+      const linkedPullSummary = createLinkedPullSummary(res);
+      setLastSummary([res?.summary || '已从本地工作区同步修改', linkedPullSummary].filter(Boolean).join('；'));
       setLastDiffSummary(res?.diffSummary || null);
-      Message.success('已同步本地 AI 修改');
+      if (linkedPullSummary) {
+        Message.warning('已同步当前页面；关联子 L4 页面也有本地修改，请分别打开对应 L4 页面同步并保存');
+      } else {
+        Message.success('已同步当前页面的本地修改，请预览确认后点击页面保存');
+      }
     } catch (e) {
       const detail = getJsonErrorDetail(e);
       setPullError(detail);
@@ -415,7 +815,15 @@ export default function LocalAIDrawer(props) {
       const res = await getPageStatus(baseURL, pageCode);
       setWorkspacePath(res?.dir || '');
       setLastDiffSummary(null);
-      setLastSummary(res?.exists ? `本地工作区已存在: ${res.dir}` : '本地还没有这个页面的工作区');
+      const linkedChangedCount = res?.linkedPages?.changedCount || 0;
+      const linkedStatusText = linkedChangedCount
+        ? `；关联 L4 页面中有 ${linkedChangedCount} 个存在本地修改`
+        : res?.linkedPages?.totalReferences
+          ? `；已记录关联 L4 页面 ${res.linkedPages.totalReferences} 个`
+          : '';
+      setLastSummary(
+        res?.exists ? `本地工作区已存在: ${res.dir}${linkedStatusText}` : '本地还没有这个页面的工作区',
+      );
       Message.success(res?.exists ? '本地工作区已存在' : '本地工作区不存在');
     } catch (e) {
       Message.error(e.message || '查询本地工作区失败');
@@ -516,6 +924,9 @@ export default function LocalAIDrawer(props) {
             回滚上次更改
           </CnButton>
         </div>
+        <div className="mdd-local-ai-action-notice">
+          “同步本地修改”只会同步当前页面的本地变更；如果关联子 L4 页面也在本地改过，请打开对应子页面的 L4 地址，分别执行“同步本地修改”并在页面上点击保存。
+        </div>
       </div>
 
       <div className="mdd-local-ai-section">
@@ -533,7 +944,85 @@ export default function LocalAIDrawer(props) {
         </div>
       </div>
 
-      {lastSummary ? <div className="mdd-local-ai-summary">{lastSummary}</div> : null}
+      {lastSummary ? (
+        lastSummary.type === 'push' ? (
+          <div className="mdd-local-ai-push-result">
+            <div className="mdd-local-ai-push-result-head">
+              <div>
+                <div className="mdd-local-ai-push-result-title">已写入本地工作区</div>
+                <div className="mdd-local-ai-push-result-path">{lastSummary.dir}</div>
+              </div>
+              <span className="mdd-local-ai-push-result-badge">完成</span>
+            </div>
+
+            <div className="mdd-local-ai-push-stats">
+              <div className="mdd-local-ai-push-stat">
+                <span>直接子 L4</span>
+                <strong>{lastSummary.linkedPages?.directCount || 0}</strong>
+              </div>
+              <div className="mdd-local-ai-push-stat">
+                <span>递归关联</span>
+                <strong>{lastSummary.linkedPages?.totalReferences || 0}</strong>
+              </div>
+              <div className="mdd-local-ai-push-stat is-success">
+                <span>已同步</span>
+                <strong>{lastSummary.linkedPages?.syncedCount || 0}</strong>
+              </div>
+              <div className="mdd-local-ai-push-stat is-warning">
+                <span>需处理</span>
+                <strong>{lastSummary.linkedPages?.failedCount || 0}</strong>
+              </div>
+            </div>
+
+            {lastSummary.linkedPages?.pages?.length ? (
+              <div className="mdd-local-ai-linked-section">
+                <div className="mdd-local-ai-linked-section-title">已一起同步的关联页面</div>
+                <div className="mdd-local-ai-linked-tags">
+                  {lastSummary.linkedPages.pages.map((page) => (
+                    <span key={page.code} className="mdd-local-ai-linked-tag is-success has-name">
+                      <span className="mdd-local-ai-linked-name">{page.name || '未命名页面'}</span>
+                      <span className="mdd-local-ai-linked-code">{page.code}</span>
+                    </span>
+                  ))}
+                </div>
+              </div>
+            ) : null}
+
+            {lastSummary.linkedPages?.failed?.length ? (
+              <div className="mdd-local-ai-linked-section">
+                <div className="mdd-local-ai-linked-section-title">需要用户处理的关联页面</div>
+                {lastSummary.linkedPages.failed.map((page) => {
+                  const isLocalChangeSkipped = isLocalChangeSkippedPage(page);
+                  return (
+                    <div key={page.code} className="mdd-local-ai-linked-warning">
+                      <div className="mdd-local-ai-linked-warning-main">
+                        <span className="mdd-local-ai-linked-tag is-warning has-name">
+                          <span className="mdd-local-ai-linked-name">{page.name || '未命名页面'}</span>
+                          <span className="mdd-local-ai-linked-code">{page.code}</span>
+                        </span>
+                        <span>{page.reason || '未能自动同步'}</span>
+                      </div>
+                      {isLocalChangeSkipped ? (
+                        <div className="mdd-local-ai-linked-actions-tip">
+                          <div>这个页面本地已有未同步修改，为避免覆盖，本次没有重新下发。</div>
+                          <div>你可以选择：1）打开该 L4 页面先“同步本地修改”并保存；2）确认放弃本地改动后删除本地目录，再从父页面重新下发。</div>
+                          {page.dir ? (
+                            <CnButton size="small" onClick={() => handleCopy(page.dir, '已复制关联页面本地目录')}>
+                              复制本地目录
+                            </CnButton>
+                          ) : null}
+                        </div>
+                      ) : null}
+                    </div>
+                  );
+                })}
+              </div>
+            ) : null}
+          </div>
+        ) : (
+          <div className="mdd-local-ai-summary">{lastSummary}</div>
+        )
+      ) : null}
 
       <PullDiffDetail diffSummary={lastDiffSummary} />
 

package/src/ai/bridgeClient.js

@@ -183,6 +183,7 @@ export function normalizeBridgeConfig(config) {
     };
   }
   return {
+    ...(config || {}),
     enabled: config?.enabled !== false,
     baseURL: config?.baseURL || DEFAULT_BRIDGE_URL,
   };