src/
├── trunk/          # 庫層·內套娃模式·modus→三維張量·範疇掩碼→NPU驅動
│   ├── gover/      # 9維原語·思想範疇（嚴格緊緻態規則）
│   ├── cover/      # 9維原語·邏輯原色（完全鬆散態規則）
│   ├── hover/      # 共現進程·組合推論規則（伺服跟隨核心）
│   ├── modus_processor/ # 範疇掩碼處理（三維張量·力矩跟隨）
│   │   ├── tensor_adapter.py # 力矩參數適配（外壓/張力/深度量化）
│   │   ├── ulam_element.py # 原始烏拉姆元素管理（散列數列處理）
│   │   └── coexistence_rule.py # 共現進程組合推論規則實現
│   ├── npu_driver/ # NPU驅動適配（演繹推理·範疇掩碼創新）
│   └── init.py     # 庫層初始化（9維空間參數加載+NPU連接）
├── frame/          # 程序層·上套裝模式·mode→二維向量·分類偽碼→GPU驅動
│   ├── scheduler/  # 步進增量調度（三維時間·開環控制）
│   │   ├── step_controller.py # 步進步長管理（速度跟隨·二維向量量化）
│   │   └── zero_alignment.py # 三平面零點校準（Master調度接口）
│   ├── pubsub/     # 三核通信隊列（GPU-CPU-NPU數據交互）
│   ├── mode_adapter/ # 分類偽碼處理（二維向量·速度跟隨）
│   │   ├── vector_processor.py # 工作空間參數計算（度量衡體系適配）
│   │   └── interface_rule.py # 分類偽碼接口規則（APIs實現）
│   ├── gpu_driver/ # GPU驅動適配（並行計算·分類偽碼執行）
│   └── init.py     # 程序層初始化（三維時間參數加載+GPU連接）
├── node/           # 文檔層·主模式·pattern→一維標量·目錄明碼→CPU驅動
│   ├── pattern_filter/ # 目錄明碼處理（一維標量·位置跟隨）
│   │   ├── scalar_parser.py # 命名空間+文檔常量解析（座標標架系適配）
│   │   └── standard_template.py # 標準模板術語管理
│   ├── mermaid/    # 哈斯圖可視化生成（雙級狀態+共現進程）
│   ├── cpu_driver/ # CPU驅動適配（串行控制·目錄明碼解析）
│   └── init.py     # 文檔層初始化（一維標量參數加載+CPU連接）
├── common/         # 公共模塊·三平面共享工具
│   ├── zero_calibrator.py # 零點對齊工具（Master調用核心）
│   ├── three_core_communicator.py # 三核通信工具（基於ANIs/APIs擴展）
│   └── term_validator.py # 術語合規校驗（雙級邊界+推論規則）
└── master/         # CNC式主控模塊（核心控制·自動生成執行程序）
    ├── master_controller.py # 三平面調度（零點對齊+進程監控）
    ├── program_generator.py # 執行程序自動生成（Designer→控制腳本）
    ├── deformation_monitor.py # Transformer變形狀態可視化
    └── delivery_handler.py # 交付流程管理（組裝邏輯+腳本導出）

graph TD
    A[Designer：邏輯定義+可視化呈現] -->|輸出：邏輯規則/術語/可視化藍圖| B[Master：集中控制+程序生成]
    B -->|輸出：控制指令/執行腳本/零點基準| C[Transformer：物理執行+狀態反饋]
    C -->|反饋：執行狀態/故障信息/優化建議| A
    A -->|同步：邏輯變更通知| B
    B -->|同步：控制策略調整| C
    C -->|同步：硬件狀態數據| B

meta_engine/
├── global_common/          # 全局公共模塊（三體共享）
│   ├── data_protocol/      # 數據交互協議實現（按《三體數據交互協議規範》開發）
│   ├── term_validator/     # 術語合規校驗工具（基於全局術語字典）
│   ├── log_tool/           # 全鏈路日誌工具（統一日誌格式）
│   └── sync_adapter/       # 協同適配層（處理三體同步/反饋/變更）
├── designer_project/       # Designer項目（邏輯定義+可視化呈現）
├── master_project/         # Master項目（集中控制+程序生成）
├── transformer_project/    # Transformer項目（物理執行+狀態反饋）
├── global_docs/            # 全局總綱文檔
└── development_plan/       # 開發規劃表+開發指南

designer_project/
├── src/
│   ├── core_logic/         # 核心邏輯定義模塊
│   │   ├── nine_dim_primitive/ # 9維原語管理（Gover/Cover/Hover）
│   │   │   ├── primitive_editor.py # 原語編輯（新增/修改/刪除）
│   │   │   ├── primitive_align.py # 原語對齊校驗
│   │   │   └── core_primitive.yaml # 原語配置文件
│   │   ├── high_order_rule/ # 高階規則（Functor）實現
│   │   │   ├── formal_grammar/ # 形式語言文法（Type-Ⅰ/Ⅱ/Ⅲ）
│   │   │   ├── natural_grammar/ # 自然語言語法（BNF/EBNF/ABNF）
│   │   │   └── artificial_usage/ # 人工語言用法（Type-0+cfr）
│   │   └── low_order_rule/ # 低階規則（Letter）實現
│   │       ├── fixed_word_connect.py # 固定詞連接（可替換）
│   │       ├── non_terminal_extend.py # 非閉合符號擴展（可擴展）
│   │       └── terminal_simplify.py # 閉合符號簡約（可簡約）
│   ├── visualization/      # 可視化呈現模塊
│   │   ├── hasse_diagram/  # 哈斯圖生成（雙級狀態+共現進程）
│   │   ├── mermaid_generator.py # mermaid圖表導出
│   │   └── document_exporter.py # 設計文檔自動生成
│   ├── sync_module/        # 協同模塊（與Master/Transformer同步）
│   │   ├── status_receiver.py # 接收Master/Transformer狀態反饋
│   │   └── logic_changer.py # 邏輯變更管理（按變更流程執行）
│   └── common/             # Designer公共工具
│       ├── rule_validator.py # 規則合規校驗（高階約束低階）
│       └── term_dictionary.py # 術語字典管理
├── config/                 # Designer配置目錄
│   ├── rule_config/        # 規則配置文件（高階/低階）
│   └── visualization_config/ # 可視化配置（圖表樣式/輸出格式）
├── tests/                  # Designer測試目錄
│   ├── unit_tests/         # 單元測試（核心邏輯/可視化模塊）
│   └── sync_tests/         # 協同測試（與Master/Transformer數據交互）
└── designer_docs/          # Designer專屬文檔

master_project/
├── src/
│   ├── core_control/       # 核心控制模塊
│   │   ├── zero_alignment/ # 三平面零點對齊
│   │   │   ├── alignment_algorithm.py # 對齊算法實現
│   │   │   └── error_correction.py # 誤差修正
│   │   ├── process_monitor.py # 執行狀態監控
│   │   └── fault_handler.py # 故障處理（冗餘切換）
│   ├── program_generator/  # 執行程序生成模塊
│   │   ├── script_template/ # 執行腳本模板（適配Transformer）
│   │   ├── variable_mapper.py # 變量替換（基於Designer邏輯）
│   │   └── core_allocation.py # 三核算力分配映射
│   ├── sync_module/        # 協同模塊（與Designer/Transformer同步）
│   │   ├── logic_receiver.py # 接收Designer邏輯輸出
│   │   ├── command_sender.py # 向Transformer發送控制指令
│   │   └── status_feedback.py # 向Designer反饋執行狀態
│   └── common/             # Master公共工具
│       ├── protocol_adapter.py # 數據協議適配（對接全局協同層）
│       └── log_monitor.py # 日誌監控（分析Transformer執行日誌）
├── config/                 # Master配置目錄
│   ├── control_config/     # 控制參數配置（對齊閾值/監控頻率）
│   └── generator_config/   # 程序生成配置（模板路徑/分配規則）
├── tests/                  # Master測試目錄
│   ├── unit_tests/         # 單元測試（控制邏輯/程序生成）
│   └── integration_tests/  # 集成測試（與Designer/Transformer聯調）
└── master_docs/            # Master專屬文檔

transformer_project/
├── src/
│   ├── core_execution/     # 核心執行模塊
│   │   ├── servo_step_driver/ # 混合伺服-步進電機驅動
│   │   │   ├── servo_follow.py # 伺服跟隨（9維共現）
│   │   │   └── step_increment.py # 步進增量（三維時間）
│   │   ├── three_core/     # 三核協同執行
│   │   │   ├── cpu_executor.py # CPU（串行解析目錄明碼）
│   │   │   ├── gpu_executor.py # GPU（並行計算分類偽碼）
│   │   │   └── npu_executor.py # NPU（適配範疇掩碼）
│   │   └── three_dim_control/ # 三維跟隨控制
│   │       ├── scalar_position.py # 一維標量（位置）
│   │       ├── vector_speed.py # 二維向量（速度）
│   │       └── tensor_torque.py # 三維張量（力矩）
│   ├── interface_impl/     # 接口實現模塊
│   │   ├── anis_impl.py # ANIs接口（機械任務執行）
│   │   ├── apis_impl.py # APIs接口（人機交互適配）
│   │   └── spis_impl.py # SPIs接口（機器側過濾）
│   ├── sync_module/        # 協同模塊（與Master同步）
│   │   ├── command_receiver.py # 接收Master控制指令
│   │   └── status_sender.py # 向Master反饋執行狀態
│   └── common/             # Transformer公共工具
│       ├── hardware_adapter.py # 硬件適配工具
│       └── precision_calibrator.py # 精度校準工具
├── config/                 # Transformer配置目錄
│   ├── driver_config/      # 驅動參數配置（伺服/步進）
│   └── interface_config/   # 接口配置（端口/超時閾值）
├── tests/                  # Transformer測試目錄
│   ├── unit_tests/         # 單元測試（驅動/接口/三核執行）
│   └── hardware_tests/     # 硬件測試（與物理設備聯調）
└── transformer_docs/       # Transformer專屬文檔

graph TD
    A[用户交互層] -->|操作輸入/結果展示| B[核心功能層]
    B --> C[MD文檔管理模塊]
    B --> D[項目結構生成模塊]
    B --> E[交接面管理模塊]
    B --> F[測試管理模塊]
    B --> G[術語管理模塊]
    B --> H[變更管理模塊]
    B --> I[交付物跟蹤模塊]
    J[數據存儲層] -->|存儲數據| B
    G -->|提供術語數據| C/D/E/F/I[所有模塊依賴術語管理]

project_planning_tool/
├── app/
│   ├── __init__.py          # Flask應用初始化
│   ├── models/              # 數據模型（對應SQLite表）
│   │   ├── __init__.py
│   │   ├── term.py          # 術語模型
│   │   ├── document.py      # 文檔模型
│   │   ├── structure.py     # 項目結構模型
│   │   ├── interface.py     # 交接面模型
│   │   ├── test_case.py     # 測試用例模型
│   │   ├── change.py        # 變更記錄模型
│   │   └── deliverable.py   # 交付物模型
│   ├── routes/              # 路由（界面訪問入口）
│   │   ├── __init__.py
│   │   ├── term_routes.py   # 術語管理路由
│   │   ├── doc_routes.py    # 文檔管理路由
│   │   ├── structure_routes.py # 項目結構路由
│   │   ├── interface_routes.py # 交接面路由
│   │   ├── test_routes.py   # 測試管理路由
│   │   ├── change_routes.py # 變更管理路由
│   │   └── deliverable_routes.py # 交付物路由
│   ├── services/            # 核心業務邏輯
│   │   ├── __init__.py
│   │   ├── term_service.py  # 術語校驗、關聯邏輯
│   │   ├── doc_service.py   # MD文檔編輯、標註、版本管理
│   │   ├── structure_service.py # 項目結構生成、導出
│   │   ├── interface_service.py # 交接面關聯、校驗
│   │   ├── test_service.py  # 測試用例關聯、報告生成
│   │   ├── change_service.py # 變更影響範圍分析
│   │   └── deliverable_service.py # 交付物狀態跟蹤
│   ├── static/              # 靜態資源（CSS/JS/圖片）
│   │   ├── css/             # Bootstrap樣式
│   │   ├── js/              # jQuery、Editor.md、Mermaid.js
│   │   └── plugins/         # Editor.md插件
│   └── templates/           # 前端模板（HTML）
│       ├── base.html        # 基礎模板（導航欄、頁腳）
│       ├── term/            # 術語管理頁面
│       ├── doc/             # 文檔管理頁面
│       ├── structure/       # 項目結構頁面
│       ├── interface/       # 交接面頁面
│       ├── test/            # 測試管理頁面
│       ├── change/          # 變更管理頁面
│       └── deliverable/     # 交付物頁面
├── config.py                # 配置文件（數據庫路徑、端口、模板路徑）
├── run.py                   # 程序入口（啓動Flask服務）
├── init_data/               # 初始化數據（全局術語字典、標準項目結構、文檔模板）
│   ├── global_terms.yaml    # 全局術語字典（來自之前的共識）
│   ├── project_structures/  # 三套項目標準結構（JSON文件）
│   └── doc_templates/       # MD文檔模板（按類型分類）
├── data/                    # 數據存儲（SQLite數據庫文件）
│   └── project_tool.db      # 自動生成的數據庫文件
└── requirements.txt         # 依賴包清單

from app import create_app
import os
# 創建Flask應用
app = create_app()
if __name__ == '__main__':
    # 確保數據目錄存在
    if not os.path.exists('data'):
        os.makedirs('data')
    # 本地運行，端口5000，調試模式開啓（自用方便）
    app.run(host='127.0.0.1', port=5000, debug=True)

from app import db
from datetime import datetime
class Term(db.Model):
    __tablename__ = 'terms'
    term_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    term_name = db.Column(db.String(50), unique=True, nullable=False)
    term_definition = db.Column(db.Text, nullable=False)
    term_category = db.Column(db.String(30), nullable=False)
    related_terms = db.Column(db.String(200))  # 逗號分隔的term_id
    create_time = db.Column(db.DateTime, default=datetime.utcnow)
    update_time = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    # 關聯文檔（一對多）
    documents = db.relationship('Document', backref='term', lazy=True)
    # 關聯項目結構（一對多）
    structures = db.relationship('ProjectStructure', backref='term', lazy=True)
    def to_dict(self):
        """轉換為字典，用於前端展示"""
        return {
            'term_id': self.term_id,
            'term_name': self.term_name,
            'term_definition': self.term_definition,
            'term_category': self.term_category,
            'related_terms': self.related_terms.split(',') if self.related_terms else [],
            'create_time': self.create_time.strftime('%Y-%m-%d %H:%M:%S'),
            'update_time': self.update_time.strftime('%Y-%m-%d %H:%M:%S')
        }

import os
import json
from app.models.structure import ProjectStructure
from app import db
def load_standard_structures(project_name):
    """加載標準項目結構（來自init_data）"""
    structure_path = f'init_data/project_structures/{project_name.lower()}_structure.json'
    if not os.path.exists(structure_path):
        return None
    with open(structure_path, 'r', encoding='utf-8') as f:
        return json.load(f)
def generate_project_structure(project_name, export_path):
    """生成項目結構到本地目錄"""
    # 加載標準結構
    standard_structures = load_standard_structures(project_name)
    if not standard_structures:
        return False, f'未找到{project_name}的標準結構'
    # 遞歸創建目錄和文件
    for item in standard_structures:
        full_path = os.path.join(export_path, item['directory_path'], item['file_name'])
        dir_path = os.path.dirname(full_path)
        if not os.path.exists(dir_path):
            os.makedirs(dir_path)
        # 如果是文件，創建空文件並寫入術語説明
        if item['file_type'] != '目錄':
            with open(full_path, 'w', encoding='utf-8') as f:
                term_name = item.get('related_term', '無關聯術語')
                description = item.get('description', '無描述')
                f.write(f"# {item['file_name']}\n")
                f.write(f"## 關聯術語：{term_name}\n")
                f.write(f"## 模塊描述：{description}\n")
                f.write(f"## 注意：修改文件名需從術語庫選擇，禁止自定義非共識術語\n")
        # 保存到數據庫
        existing = ProjectStructure.query.filter_by(
            project_name=project_name,
            directory_path=item['directory_path'],
            file_name=item['file_name']
        ).first()
        if not existing:
            structure = ProjectStructure(
                project_name=project_name,
                directory_path=item['directory_path'],
                file_name=item['file_name'],
                related_term_id=item.get('related_term_id', None),
                file_type=item['file_type'],
                description=item.get('description', '')
            )
            db.session.add(structure)
    db.session.commit()
    return True, f'{project_name}項目結構已生成到：{export_path}'

import os
import markdown
from app.models.document import Document
from app.models.term import Term
from app import db
from datetime import datetime
def create_doc_from_template(doc_name, doc_type, creator):
    """從模板創建MD文檔"""
    # 查找模板文件
    template_path = f'init_data/doc_templates/{doc_type.lower()}_template.md'
    if not os.path.exists(template_path):
        return False, f'未找到{doc_type}的模板'
    # 讀取模板內容
    with open(template_path, 'r', encoding='utf-8') as f:
        template_content = f.read()
    # 生成文檔路徑
    doc_dir = f'data/documents/{doc_type}'
    if not os.path.exists(doc_dir):
        os.makedirs(doc_dir)
    doc_path = os.path.join(doc_dir, doc_name)
    if not doc_path.endswith('.md'):
        doc_path += '.md'
    # 保存文檔文件
    with open(doc_path, 'w', encoding='utf-8') as f:
        f.write(template_content)
    # 保存到數據庫
    doc = Document(
        doc_name=doc_name,
        doc_type=doc_type,
        doc_path=doc_path,
        doc_version='V1.0',
        related_terms='',
        create_time=datetime.utcnow(),
        update_time=datetime.utcnow(),
        creator=creator
    )
    db.session.add(doc)
    db.session.commit()
    return True, doc_path
def add_term_annotation(doc_id, term_id):
    """為文檔添加術語標註"""
    doc = Document.query.get(doc_id)
    term = Term.query.get(term_id)
    if not doc or not term:
        return False, '文檔或術語不存在'
    # 讀取文檔內容
    with open(doc.doc_path, 'r', encoding='utf-8') as f:
        content = f.read()
    # 標註格式：[[術語名::術語定義]]
    annotation = f'[[{term.term_name}::{term.term_definition}]]'
    # 在文檔末尾添加標註（或替換指定位置，自用簡化處理）
    content += f'\n\n## 術語標註\n{annotation}'
    # 保存修改後的文檔
    with open(doc.doc_path, 'w', encoding='utf-8') as f:
        f.write(content)
    # 更新文檔關聯術語
    related_terms = doc.related_terms.split(',') if doc.related_terms else []
    if str(term_id) not in related_terms:
        related_terms.append(str(term_id))
        doc.related_terms = ','.join(related_terms)
        doc.doc_version = f"V{float(doc.doc_version[1:]) + 0.1:.1f}"  # 版本遞增
        doc.update_time = datetime.utcnow()
        db.session.commit()
    return True, '標註成功'
def validate_doc_terms(doc_id):
    """校驗文檔術語一致性"""
    doc = Document.query.get(doc_id)
    if not doc:
        return False, '文檔不存在'
    # 讀取文檔內容
    with open(doc.doc_path, 'r', encoding='utf-8') as f:
        content = f.read()
    # 獲取所有已收錄術語
    all_terms = [term.term_name.lower() for term in Term.query.all()]
    # 簡單校驗：查找文檔中可能的術語（這裏簡化為全匹配，自用足夠）
    invalid_terms = []
    for word in content.split():
        # 過濾標點符號
        clean_word = word.strip('.,;:()[]{}""''').lower()
        if clean_word and clean_word not in all_terms and len(clean_word) > 2:
            invalid_terms.append(word)
    if invalid_terms:
        return False, f'發現未收錄術語（可能拼寫錯誤或非共識術語）：{", ".join(list(set(invalid_terms)))}'
    return True, '術語一致性校驗通過'

- term_name: pattern
  term_definition: 主模式·文檔層核心模式詞彙，核心功能為特徵提取-適用過濾，關聯productor程序+九宮格+SPIs接口+Hover層
  term_category: 模式詞彙
  related_terms: 文檔層,SPIs,Hover,特徵提取-適用過濾
- term_name: mode
  term_definition: 上套裝模式·程序層核心模式詞彙，核心功能為知識表徵-適配調節，關聯projector程序+格框+APIs接口+Cover層
  term_category: 模式詞彙
  related_terms: 程序層,APIs,Cover,知識表徵-適配調節
- term_name: modus
  term_definition: 內套娃模式·庫層核心模式詞彙，核心功能為數據共享-適應處理，關聯master程序+格架+ANIs接口+Gover層
  term_category: 模式詞彙
  related_terms: 庫層,ANIs,Gover,數據共享-適應處理
# 此處省略其他術語，按之前的《全局術語字典》補充完整

[
  {
    "directory_path": "designer_project/src/core_logic/nine_dim_primitive",
    "file_name": "primitive_editor.py",
    "related_term": "9維原語",
    "related_term_id": 1,
    "file_type": "Python文件",
    "description": "9維原語編輯功能，支持原語新增/修改/刪除"
  },
  {
    "directory_path": "designer_project/src/core_logic/nine_dim_primitive",
    "file_name": "core_primitive.yaml",
    "related_term": "9維原語",
    "related_term_id": 1,
    "file_type": "配置文件",
    "description": "9維原語配置文件，存儲Gover/Cover/Hover原語定義"
  }
  // 此處省略其他目錄和文件，按之前的Designer項目結構補充完整
]

graph TD
    A[用户交互層] -->|操作輸入/結果展示| B[核心功能層]
    B --> C[MD文檔管理模塊]
    B --> D[項目結構生成模塊]
    B --> E[交接面管理模塊]
    B --> F[測試管理模塊]
    B --> G[術語管理模塊]
    B --> H[變更管理模塊]
    B --> I[交付物跟蹤模塊]
    # 新增擴展層（類LDAP/TSN/DNS）
    J[擴展層] --> J1[類DNS文檔外殼模塊]
    J --> J2[類LDAP程序結構包裝器模塊]
    J --> J3[類TSN術語封裝模塊]
    # 核心層與擴展層聯動
    C --> J1[類DNS：文檔標準化+外接部署]
    D --> J2[類LDAP：結構打包+外接平台]
    G --> J3[類TSN：術語封裝+外接算法]
    E --> J1/J2/J3[交接面關聯外接資源]
    F --> J3[測試調用外接算法]
    I --> J1/J2[交付物外接部署/導入]
    # 數據存儲層與外接接口
    K[數據存儲層] -->|存儲數據| B/J
    L[外接接口層] -->|REST API+SDK| J1/J2/J3[外部系統接入]
    L --> 外部開發平台[GitLab CI/Jenkins]
    L --> 外部算法[術語抽取/測試算法]
    L --> 外部環境[K8s/訓練平台]

class StructurePackage(db.Model):
    __tablename__ = 'structure_packages'
    package_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    project_name = db.Column(db.String(30), nullable=False)  # Designer/Master/Transformer
    package_format = db.Column(db.String(20), nullable=False)  # zip/docker
    package_path = db.Column(db.String(255), nullable=False)  # 本地存儲路徑
    metadata_json = db.Column(db.Text, nullable=False)  # 標準化元數據
    related_terms = db.Column(db.String(200))  # 關聯術語ID（逗號分隔）
    external_platform = db.Column(db.String(50))  # 外接平台（如GitLab CI）
    package_time = db.Column(db.DateTime, default=datetime.utcnow)
    operator = db.Column(db.String(50))  # 操作人

import os
import json
import docker
from app.models.structure import ProjectStructure
from app.models.structure_package import StructurePackage
from app import db
# 初始化Docker客户端（外接模式使用）
docker_client = docker.from_env() if docker.from_env().ping() else None
def package_project_structure(project_name, package_format, external_platform=None):
    """打包項目結構（類LDAP包裝器核心功能）"""
    # 1. 獲取項目結構數據
    structures = ProjectStructure.query.filter_by(project_name=project_name).all()
    if not structures:
        return False, f'{project_name}無結構數據'
    # 2. 生成標準化元數據
    related_terms = set()
    dir_files = []
    for s in structures:
        if s.related_term_id:
            related_terms.add(str(s.related_term_id))
        dir_files.append({
            'directory_path': s.directory_path,
            'file_name': s.file_name,
            'file_type': s.file_type,
            'description': s.description
        })
    metadata = {
        'project_name': project_name,
        'structure_version': 'V1.0',
        'related_terms': list(related_terms),
        'directory_count': len([f for f in dir_files if f['file_type'] == '目錄']),
        'file_count': len([f for f in dir_files if f['file_type'] != '目錄']),
        'create_time': datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S'),
        'package_format': package_format,
        'external_platform': external_platform or 'local'
    }
    # 3. 打包生成文件
    package_dir = f'data/packages/structure/{project_name}'
    if not os.path.exists(package_dir):
        os.makedirs(package_dir)
    if package_format == 'zip':
        # 生成ZIP包
        import zipfile
        package_path = os.path.join(package_dir, f'{project_name}_structure.zip')
        with zipfile.ZipFile(package_path, 'w', zipfile.ZIP_DEFLATED) as zf:
            # 寫入元數據
            zf.writestr('metadata.json', json.dumps(metadata, ensure_ascii=False, indent=2))
            # 寫入空目錄/文件（模擬項目結構）
            for item in dir_files:
                full_path = os.path.join(item['directory_path'], item['file_name'])
                zf.writestr(full_path, '')  # 空文件，僅保留結構
    elif package_format == 'docker':
        # 生成Docker鏡像（需本地安裝Docker）
        if not docker_client:
            return False, '未安裝Docker，無法生成鏡像'
        # 創建Dockerfile
        dockerfile_content = f"""FROM alpine:latest
LABEL project={project_name}
LABEL structure_version={metadata['structure_version']}
# 複製項目結構元數據
COPY metadata.json /app/metadata.json
# 創建空目錄結構
"""
        for item in dir_files:
            if item['file_type'] == '目錄':
                dockerfile_content += f"RUN mkdir -p /app/{item['directory_path']}\n"
        # 寫入Dockerfile
        dockerfile_path = os.path.join(package_dir, 'Dockerfile')
        with open(dockerfile_path, 'w', encoding='utf-8') as f:
            f.write(dockerfile_content)
        # 寫入元數據
        with open(os.path.join(package_dir, 'metadata.json'), 'w', encoding='utf-8') as f:
            f.write(json.dumps(metadata, ensure_ascii=False, indent=2))
        # 構建鏡像
        image_tag = f'{project_name.lower()}_structure:{metadata["structure_version"]}'
        docker_client.images.build(path=package_dir, tag=image_tag)
        package_path = image_tag  # Docker鏡像標籤作為路徑
    else:
        return False, '不支持的打包格式（僅支持zip/docker）'
    # 4. 保存打包記錄到數據庫
    package = StructurePackage(
        project_name=project_name,
        package_format=package_format,
        package_path=package_path,
        metadata_json=json.dumps(metadata, ensure_ascii=False),
        related_terms=','.join(related_terms) if related_terms else '',
        external_platform=external_platform,
        operator='admin'  # 自用場景簡化，可擴展為登錄用户
    )
    db.session.add(package)
    db.session.commit()
    return True, f'打包成功，路徑/鏡像標籤：{package_path}'
def import_external_structure(external_url, project_name):
    """導入外部平台項目結構（如GitLab CI、外部模型）"""
    # 簡化實現：支持HTTP下載ZIP包或Docker鏡像拉取
    if external_url.startswith('http'):
        # 下載ZIP包
        import requests
        response = requests.get(external_url)
        if response.status_code != 200:
            return False, '外部資源下載失敗'
        package_dir = f'data/packages/structure/{project_name}'
        package_path = os.path.join(package_dir, 'external_structure.zip')
        with open(package_path, 'wb') as f:
            f.write(response.content)
        # 解析元數據
        with zipfile.ZipFile(package_path, 'r') as zf:
            if 'metadata.json' not in zf.namelist():
                return False, '外部包缺少標準化元數據'
            metadata = json.loads(zf.read('metadata.json').decode('utf-8'))
    elif external_url.startswith('docker://'):
        # 拉取Docker鏡像
        if not docker_client:
            return False, '未安裝Docker，無法拉取鏡像'
        image_tag = external_url.replace('docker://', '')
        docker_client.images.pull(image_tag)
        # 從鏡像中提取元數據（簡化：假設鏡像內有/app/metadata.json）
        container = docker_client.containers.create(image_tag)
        try:
            metadata = json.loads(container.exec_run('cat /app/metadata.json').output.decode('utf-8'))
        except Exception as e:
            return False, f'提取鏡像元數據失敗：{str(e)}'
        finally:
            container.remove()
        package_path = image_tag
    else:
        return False, '不支持的外部資源格式（僅支持HTTP ZIP/docker鏡像）'
    # 5. 導入結構到工具數據庫（自動關聯術語）
    # （此處省略結構解析與入庫邏輯，核心是按metadata和dir_files創建ProjectStructure記錄）
    return True, f'外部結構導入成功，元數據：{json.dumps(metadata, indent=2)}'

class TermApiLog(db.Model):
    __tablename__ = 'term_api_log'
    log_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    api_path = db.Column(db.String(100), nullable=False)  # 調用的API路徑
    request_params = db.Column(db.Text)  # 請求參數
    response_result = db.Column(db.Text)  # 響應結果
    external_system = db.Column(db.String(50))  # 外接系統名稱
    request_time = db.Column(db.DateTime, default=datetime.utcnow)
    status = db.Column(db.String(20), nullable=False)  # success/fail

import json
from pyld import jsonld
from app.models.term import Term
from app.models.term_api_log import TermApiLog
from app import db
# JSON-LD上下文（標準化術語語義）
TERM_JSONLD_CONTEXT = {
    "@context": {
        "termName": "http://schema.org/name",
        "termDefinition": "http://schema.org/description",
        "termCategory": "http://schema.org/category",
        "relatedTerms": "http://schema.org/relatedItem",
        "createTime": "http://schema.org/dateCreated"
    }
}
def get_term_by_id(term_id, output_format='json'):
    """獲取術語（支持JSON/JSON-LD格式）"""
    term = Term.query.get(term_id)
    if not term:
        return False, '術語不存在'
    term_dict = term.to_dict()
    if output_format == 'json-ld':
        # 轉換為JSON-LD格式
        jsonld_term = {
            "@type": "Term",
            "termName": term.term_name,
            "termDefinition": term.term_definition,
            "termCategory": term.term_category,
            "relatedTerms": [{"@type": "Term", "termName": Term.query.get(tid).term_name} for tid in term_dict['related_terms'] if Term.query.get(tid)],
            "createTime": term.create_time.strftime('%Y-%m-%d %H:%M:%S')
        }
        jsonld_term.update(TERM_JSONLD_CONTEXT)
        # 壓縮JSON-LD（可選）
        compacted = jsonld.compact(jsonld_term, TERM_JSONLD_CONTEXT)
        return True, compacted
    return True, term_dict
def validate_text_terms(text, external_validate_api=None):
    """校驗文本中的術語一致性（支持調用外部算法）"""
    if external_validate_api:
        # 調用外部校驗算法（如NLP術語一致性檢查服務）
        import requests
        try:
            response = requests.post(external_validate_api, json={'text': text})
            response.raise_for_status()
            external_result = response.json()
            # 記錄外接調用日誌
            log = TermApiLog(
                api_path=external_validate_api,
                request_params=json.dumps({'text': text}),
                response_result=json.dumps(external_result),
                external_system='external_validate_algorithm',
                status='success'
            )
            db.session.add(log)
            db.session.commit()
            return True, external_result
        except Exception as e:
            log = TermApiLog(
                api_path=external_validate_api,
                request_params=json.dumps({'text': text}),
                response_result=str(e),
                external_system='external_validate_algorithm',
                status='fail'
            )
            db.session.add(log)
            db.session.commit()
            return False, f'外接算法調用失敗：{str(e)}'
    else:
        # 工具內置校驗（原有邏輯）
        all_terms = [term.term_name.lower() for term in Term.query.all()]
        invalid_terms = []
        for word in text.split():
            clean_word = word.strip('.,;:()[]{}""''').lower()
            if clean_word and clean_word not in all_terms and len(clean_word) > 2:
                invalid_terms.append(word)
        result = {
            'valid': len(invalid_terms) == 0,
            'invalid_terms': list(set(invalid_terms)),
            'total_terms': len(all_terms),
            'validate_method': 'internal'
        }
        return True, result
def import_terms_from_external(external_api):
    """從外部算法導入術語（如NLP術語抽取結果）"""
    import requests
    try:
        response = requests.get(external_api)
        response.raise_for_status()
        external_terms = response.json()  # 假設外部返回JSON-LD格式
        # 解析JSON-LD術語併入庫
        for term_data in external_terms:
            # 兼容JSON-LD格式
            if '@context' in term_data:
                compacted = jsonld.compact(term_data, TERM_JSONLD_CONTEXT)
                term_name = compacted.get('termName')
                term_def = compacted.get('termDefinition', '')
                term_category = compacted.get('termCategory', '未分類')
            else:
                term_name = term_data.get('term_name')
                term_def = term_data.get('term_definition', '')
                term_category = term_data.get('term_category', '未分類')
            if not term_name:
                continue
            # 避免重複
            existing = Term.query.filter_by(term_name=term_name).first()
            if not existing:
                new_term = Term(
                    term_name=term_name,
                    term_definition=term_def,
                    term_category=term_category,
                    related_terms=''
                )
                db.session.add(new_term)
        db.session.commit()
        # 記錄日誌
        log = TermApiLog(
            api_path=external_api,
            request_params='{}',
            response_result=json.dumps({'import_count': len(external_terms)}),
            external_system='external_term_extractor',
            status='success'
        )
        db.session.add(log)
        db.session.commit()
        return True, f'成功導入{len(external_terms)}個術語'
    except Exception as e:
        log = TermApiLog(
            api_path=external_api,
            request_params='{}',
            response_result=str(e),
            external_system='external_term_extractor',
            status='fail'
        )
        db.session.add(log)
        db.session.commit()
        return False, f'外部術語導入失敗：{str(e)}'

class DocDeployment(db.Model):
    __tablename__ = 'doc_deployment'
    deploy_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    doc_id = db.Column(db.Integer, db.ForeignKey('documents.doc_id'), nullable=False)
    doc_identifier = db.Column(db.String(100), nullable=False)  # doc://{doc_id}:{version}
    deploy_type = db.Column(db.String(20), nullable=False)  # local/k8s
    deploy_script_path = db.Column(db.String(255))  # 部署腳本路徑
    external_url = db.Column(db.String(255))  # 外部訪問URL（如K8s Service地址）
    train_data_path = db.Column(db.String(255))  # 訓練數據導出路徑
    deploy_time = db.Column(db.DateTime, default=datetime.utcnow)
    status = db.Column(db.String(20), nullable=False)  # deployed/failed

import os
import json
from app.models.document import Document
from app.models.doc_deployment import DocDeployment
from app import db
def get_doc_identifier(doc_id):
    """生成文檔唯一標識（類DNS尋址標識）"""
    doc = Document.query.get(doc_id)
    if not doc:
        return False, '文檔不存在'
    return True, f'doc://{doc_id}:{doc.doc_version}'
def generate_deploy_script(doc_id, deploy_type):
    """生成文檔部署腳本（本地/K8s）"""
    doc = Document.query.get(doc_id)
    if not doc:
        return False, '文檔不存在'
    # 生成唯一標識
    doc_identifier = f'doc://{doc_id}:{doc.doc_version}'
    deploy_dir = f'data/deployments/docs/{doc_id}'
    if not os.path.exists(deploy_dir):
        os.makedirs(deploy_dir)
    # 讀取文檔內容
    with open(doc.doc_path, 'r', encoding='utf-8') as f:
        doc_content = f.read()
    # 生成部署腳本
    if deploy_type == 'local':
        # 本地部署腳本（Shell）
        script_content = f"""#!/bin/bash
# 文檔部署腳本（類DNS文檔外殼）
# 文檔標識：{doc_identifier}
# 部署路徑：/opt/docs/{doc_id}
mkdir -p /opt/docs/{doc_id}
echo "{doc_content}" > /opt/docs/{doc_id}/{doc.doc_name}
# 啓動HTTP服務（8080端口）
python3 -m http.server 8080 --directory /opt/docs/{doc_id} &
echo "文檔部署成功，外部訪問URL：http://$(hostname -I | awk '{{print $1}}'):8080/{doc.doc_name}"
"""
        script_path = os.path.join(deploy_dir, 'deploy_local.sh')
        with open(script_path, 'w', encoding='utf-8') as f:
            f.write(script_content)
        # 賦予執行權限
        os.chmod(script_path, 0o755)
        external_url = f'http://localhost:8080/{doc.doc_name}'
    elif deploy_type == 'k8s':
        # K8s部署腳本（YAML）
        k8s_content = f"""apiVersion: v1
kind: ConfigMap
metadata:
  name: doc-configmap-{doc_id}
data:
  {doc.doc_name}: |
{doc_content.replace('"', '\\"').replace('\n', '\n    ')}
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: doc-nginx-{doc_id}
spec:
  replicas: 1
  selector:
    matchLabels:
      app: doc-nginx-{doc_id}
  template:
    metadata:
      labels:
        app: doc-nginx-{doc_id}
    spec:
      containers:
      - name: nginx
        image: nginx:alpine
        volumeMounts:
        - name: doc-volume
          mountPath: /usr/share/nginx/html
volumes:
- name: doc-volume
  configMap:
    name: doc-configmap-{doc_id}
---
apiVersion: v1
kind: Service
metadata:
  name: doc-service-{doc_id}
spec:
  type: NodePort
  ports:
  - port: 80
    targetPort: 80
    nodePort: 30{doc_id % 1000:03d}  # 隨機NodePort（30000-30999）
  selector:
    app: doc-nginx-{doc_id}
"""
        script_path = os.path.join(deploy_dir, 'deploy_k8s.yaml')
        with open(script_path, 'w', encoding='utf-8') as f:
            f.write(k8s_content)
        external_url = f'http://:30{doc_id % 1000:03d}/{doc.doc_name}'
    else:
        return False, '不支持的部署類型（僅支持local/k8s）'
    # 保存部署記錄
    deployment = DocDeployment(
        doc_id=doc_id,
        doc_identifier=doc_identifier,
        deploy_type=deploy_type,
        deploy_script_path=script_path,
        external_url=external_url,
        train_data_path='',
        status='deployed',
        deploy_time=datetime.utcnow()
    )
    db.session.add(deployment)
    db.session.commit()
    return True, f'部署腳本生成成功：{script_path}，外部訪問URL：{external_url}'
def export_train_data(doc_id, export_format='txt'):
    """導出文檔為訓練數據（適配外部訓練平台）"""
    doc = Document.query.get(doc_id)
    if not doc:
        return False, '文檔不存在'
    # 讀取文檔內容和元數據
    with open(doc.doc_path, 'r', encoding='utf-8') as f:
        doc_content = f.read()
    # 關聯術語
    related_terms = []
    if doc.related_terms:
        term_ids = doc.related_terms.split(',')
        related_terms = [Term.query.get(tid).term_name for tid in term_ids if Term.query.get(tid)]
    export_dir = f'data/train_data/docs/{doc_id}'
    if not os.path.exists(export_dir):
        os.makedirs(export_dir)
    if export_format == 'txt':
        # 純文本格式（僅保留文檔內容）
        export_path = os.path.join(export_dir, f'{doc.doc_name.replace(".md", "")}_train.txt')
        with open(export_path, 'w', encoding='utf-8') as f:
            f.write(doc_content)
    elif export_format == 'json':
        # JSON格式（包含內容+元數據+關聯術語）
        train_data = {
            'doc_identifier': f'doc://{doc_id}:{doc.doc_version}',
            'doc_title': doc.doc_name,
            'doc_type': doc.doc_type,
            'related_terms': related_terms,
            'content': doc_content,
            'create_time': doc.create_time.strftime('%Y-%m-%d %H:%M:%S')
        }
        export_path = os.path.join(export_dir, f'{doc.doc_name.replace(".md", "")}_train.json')
        with open(export_path, 'w', encoding='utf-8') as f:
            json.dump(train_data, f, ensure_ascii=False, indent=2)
    else:
        return False, '不支持的導出格式（僅支持txt/json）'
    # 更新部署記錄中的訓練數據路徑
    deployment = DocDeployment.query.filter_by(doc_id=doc_id).order_by(DocDeployment.deploy_time.desc()).first()
    if deployment:
        deployment.train_data_path = export_path
        db.session.commit()
    else:
        # 無部署記錄時創建
        DocDeployment(
            doc_id=doc_id,
            doc_identifier=f'doc://{doc_id}:{doc.doc_version}',
            deploy_type='train_export',
            deploy_script_path='',
            external_url='',
            train_data_path=export_path,
            status='exported',
            deploy_time=datetime.utcnow()
        )
        db.session.add(deployment)
        db.session.commit()
    return True, f'訓練數據導出成功：{export_path}'

project_planning_tool/
├── app/
│   ├── __init__.py          # Flask應用初始化（新增擴展模塊註冊）
│   ├── models/              # 數據模型（新增3個擴展表）
│   │   ├── __init__.py
│   │   ├── ...（原有模型保留）
│   │   ├── structure_package.py # 類LDAP打包記錄模型
│   │   ├── term_api_log.py  # 類TSN API調用日誌模型
│   │   └── doc_deployment.py # 類DNS部署記錄模型
│   ├── routes/              # 路由（新增擴展模塊路由）
│   │   ├── __init__.py
│   │   ├── ...（原有路由保留）
│   │   ├── ldap_routes.py   # 類LDAP模塊路由
│   │   ├── tsn_routes.py    # 類TSN模塊路由
│   │   └── dns_routes.py    # 類DNS模塊路由
│   ├── services/            # 核心業務邏輯（新增擴展模塊服務）
│   │   ├── __init__.py
│   │   ├── ...（原有服務保留）
│   │   ├── ldap_service.py  # 類LDAP服務
│   │   ├── tsn_service.py   # 類TSN服務
│   │   └── dns_service.py   # 類DNS服務
│   ├── extensions/          # 外接擴展工具（SDK/接口文檔）
│   │   ├── sdk/             # 外接SDK（Python/Java）
│   │   │   ├── python_sdk/  # Python SDK（外部平台調用工具API）
│   │   │   └── java_sdk/    # Java SDK（可選）
│   │   └── api_docs/        # 外接API文檔（Swagger UI）
│   ├── static/              # 靜態資源（新增擴展模塊前端頁面）
│   └── templates/           # 前端模板（新增擴展模塊頁面）
│       ├── ...（原有模板保留）
│       ├── ldap/            # 類LDAP模塊頁面（打包/導入）
│       ├── tsn/             # 類TSN模塊頁面（術語API/算法接入）
│       └── dns/             # 類DNS模塊頁面（部署/訓練導出）
├── config.py                # 配置文件（新增擴展模塊開關/端口配置）
├── run.py                   # 程序入口（不變）
├── init_data/               # 初始化數據（不變）
├── data/                    # 數據存儲（新增packages/deployments/train_data目錄）
└── requirements.txt         # 依賴包清單（新增docker/pyld/jsonld/requests等）

# 外部Python腳本（如GitLab CI）
import requests
API_URL = 'http://工具IP:5000/api/v1/ldap/structure/package'
params = {
    'project_name': 'Transformer',
    'package_format': 'docker',
    'external_platform': 'GitLab CI'
}
response = requests.post(API_URL, json=params)
print(response.json())
# 成功響應：{"status": "success", "message": "打包成功，路徑/鏡像標籤：transformer_structure:V1.0"}

# 外部測試工具腳本
import requests
API_URL = 'http://工具IP:5000/api/v1/tsn/term/validate'
data = {
    'text': '使用modus模式處理數據，調用ANIs接口',
    'external_validate_api': 'http://外部算法IP:8000/api/validate_terms'  # 可選：調用外部算法
}
response = requests.post(API_URL, json=data)
print(response.json())
# 響應：{"valid": true, "invalid_terms": [], "validate_method": "external"}

# 外部訓練平台腳本
import requests
API_URL = 'http://工具IP:5000/api/v1/dns/doc/export_train'
params = {
    'doc_id': 10,
    'export_format': 'json'
}
response = requests.get(API_URL, params=params)
if response.status_code == 200:
    train_data = response.json()
    # 導入到訓練平台（如TensorFlow）
    print(f'導入訓練數據：{train_data["doc_title"]}')