kcode-pi 0.1.5 → 0.1.7

package/vendor/kingdee-skills/ok-cosmic/scripts/lint/base.py

@@ -1,393 +0,0 @@
-# -*- coding: utf-8 -*-
-"""公共数据结构与工具函数，所有检查模块共享。"""
-
-import re
-from dataclasses import dataclass, field
-from enum import Enum
-from typing import Any, Dict, List, Optional, Tuple
-
-import tree_sitter
-import tree_sitter_java
-
-
-# ──────────────────────────────────────────────
-# 数据结构
-# ──────────────────────────────────────────────
-
-class Severity(str, Enum):
-    ERROR = "ERROR"      # 必定错误
-    WARNING = "WARNING"  # 场景错配 / 强烈不推荐
-    INFO = "INFO"        # 风格偏好 / 建议
-
-
-@dataclass
-class LintIssue:
-    file: str
-    line: int
-    severity: Severity
-    rule_id: str
-    message: str
-    fix_hint: str = ""
-    source_line: str = ""
-
-
-@dataclass
-class LintReport:
-    total_files: int = 0
-    total_issues: int = 0
-    errors: int = 0
-    warnings: int = 0
-    infos: int = 0
-    issues: List[LintIssue] = field(default_factory=list)
-
-    def add(self, issue: LintIssue):
-        self.issues.append(issue)
-        self.total_issues += 1
-        if issue.severity == Severity.ERROR:
-            self.errors += 1
-        elif issue.severity == Severity.WARNING:
-            self.warnings += 1
-        else:
-            self.infos += 1
-
-
-# ──────────────────────────────────────────────
-# 注释 / 字符串状态机
-# ──────────────────────────────────────────────
-
-def classify_lines(lines: List[str]) -> List[bool]:
-    """对每行标记是否为"纯注释或空行"（True=非代码行，应跳过 lint）。
-
-    使用状态机追踪多行注释块（/* ... */），
-    单行内同时识别行注释、字符串字面量，避免误判。
-    支持行中间开始的块注释（如 `code; /* comment start`）。
-    """
-    result: List[bool] = []
-    in_block_comment = False
-    in_text_block = False
-
-    for line in lines:
-        if in_text_block:
-            end_idx = line.find('"""')
-            if end_idx >= 0:
-                in_text_block = False
-                remainder = line[end_idx + 3:].strip()
-                result.append(not bool(remainder))
-            else:
-                result.append(True)
-            continue
-
-        if in_block_comment:
-            # 当前处于 /* ... */ 块注释中
-            end_idx = line.find("*/")
-            if end_idx >= 0:
-                in_block_comment = False
-                # 关闭后如果剩余部分有实质代码，视为代码行
-                remainder = line[end_idx + 2:].strip()
-                result.append(not bool(remainder))
-            else:
-                result.append(True)
-            continue
-
-        stripped = line.strip()
-
-        # 检查是否进入 Text Block (""")
-        if '"""' in stripped and stripped.count('"""') % 2 != 0:
-            in_text_block = True
-            result.append(False) # 开启"""的这一行本身属于代码声明
-            continue
-        stripped = line.strip()
-        # 空行
-        if not stripped:
-            result.append(True)
-            continue
-        # 纯单行注释
-        if stripped.startswith("//"):
-            result.append(True)
-            continue
-        # Javadoc / 多行注释续行（行首 *）
-        if stripped.startswith("*") and not stripped.startswith("*/"):
-            result.append(True)
-            continue
-        # 检查块注释开始（行首或行中间）
-        if stripped.startswith("/*"):
-            close_idx = stripped.find("*/", 2)
-            if close_idx >= 0:
-                # 单行块注释 /* ... */，检查 */ 后是否有代码
-                remainder = stripped[close_idx + 2:].strip()
-                result.append(not bool(remainder))
-            else:
-                in_block_comment = True
-                result.append(True)
-            continue
-
-        # 代码行：检查行中间是否有未闭合的 /* 开始块注释
-        # 需要排除字符串字面量内的 /*
-        if _has_unclosed_block_comment_start(stripped):
-            in_block_comment = True
-            # 行本身有代码部分，标记为代码行
-            result.append(False)
-            continue
-
-        # 其他情况：代码行（可能包含行尾注释，但行本身有代码）
-        result.append(False)
-
-    return result
-
-
-def _has_unclosed_block_comment_start(line: str) -> bool:
-    """检测行中间是否有未闭合的 /* 块注释开始（排除字符串内的 /*）。"""
-    i = 0
-    in_str = False
-    str_char = ''
-    while i < len(line):
-        c = line[i]
-        if in_str:
-            if c == '\\' and i + 1 < len(line):
-                i += 2  # 跳过转义字符
-                continue
-            if c == str_char:
-                in_str = False
-            i += 1
-            continue
-        if c in ('"', "'"):
-            in_str = True
-            str_char = c
-            i += 1
-            continue
-        if c == '/' and i + 1 < len(line):
-            if line[i + 1] == '/':
-                return False  # 行注释，不可能有 /* 了
-            if line[i + 1] == '*':
-                # 找到 /*，检查本行内是否有 */
-                close_idx = line.find('*/', i + 2)
-                if close_idx >= 0:
-                    # 同行闭合 /* ... */，跳过继续
-                    i = close_idx + 2
-                    continue
-                else:
-                    return True  # 未闭合的 /* 块注释开始
-        i += 1
-    return False
-
-
-def is_comment_or_string(line: str) -> bool:
-    """粗略判断当前行是否为注释或字符串（排除误报）。
-
-    注意：此函数为单行判断，无法追踪跨行 /* */ 状态。
-    对跨行精确判断，请使用 classify_lines() 代替。
-    """
-    stripped = line.strip()
-    if not stripped:
-        return True
-    return (stripped.startswith("//")
-            or stripped.startswith("*")
-            or stripped.startswith("/*"))
-
-
-def strip_line_comment(line: str) -> str:
-    """移除单行注释部分，保留代码主体（正确跳过字符串字面量内的 //）。"""
-    i = 0
-    in_str = False
-    str_char = ''
-    while i < len(line):
-        c = line[i]
-        if in_str:
-            if c == '\\' and i + 1 < len(line):
-                i += 2
-                continue
-            if c == str_char:
-                in_str = False
-            i += 1
-            continue
-        if c in ('"', "'"):
-            in_str = True
-            str_char = c
-            i += 1
-            continue
-        if c == '/' and i + 1 < len(line) and line[i + 1] == '/':
-            return line[:i]
-        i += 1
-    return line
-
-
-def strip_string_literals(line: str) -> str:
-    """移除字符串字面量，便于做结构分析。"""
-    return re.sub(r'"(?:\\.|[^"\\])*"|\'(?:\\.|[^\'\\])*\'', '""', line)
-
-
-def code_for_structure(line: str) -> str:
-    """用于结构分析的代码行：去掉行注释与字符串。"""
-    return strip_line_comment(strip_string_literals(line))
-
-
-METHOD_DECL_RE = re.compile(
-    r"^\s*(?:@\w+(?:\([^)]*\))?\s*)*"
-    r"(?:public|protected|private)\s+"
-    r"(?:static\s+|final\s+|synchronized\s+|abstract\s+|native\s+|default\s+)*"
-    r"[\w<>\[\], ?.@]+\s+([A-Za-z_]\w*)\s*"
-    r"\([^;{}]*\)\s*(?:throws\s+[^{]+)?\s*(?:\{)?\s*$"
-)
-
-LOOP_HEADER_RE = re.compile(r"\bfor\s*\(|\bwhile\s*\(|^\s*do\b")
-LAMBDA_ITER_RE = re.compile(r"\.\s*(forEach|map|flatMap|peek)\s*\(")
-CLASS_DECL_RE = re.compile(r"\bclass\s+[A-Za-z_]\w*")
-
-
-def looks_like_loop_header(line: str) -> bool:
-    """判断当前行是否看起来是 loop 头。"""
-    return bool(LOOP_HEADER_RE.search(code_for_structure(line)))
-
-
-def parse_java(lines: List[str]) -> Tuple[Any, Any]:
-    """解析 Java 源码，返回 (tree, language) 供多处复用，避免重复解析。"""
-    lang = tree_sitter.Language(tree_sitter_java.language())
-    parser = tree_sitter.Parser(lang)
-    src_bytes = "\n".join(lines).encode('utf-8')
-    tree = parser.parse(src_bytes)
-    return tree, lang
-
-
-def analyze_java_context(lines: List[str], tree=None) -> Tuple[List[Optional[str]], List[bool]]:
-    """
-    基于 AST 构建上下文：
-    - 每行所在方法名
-    - 每行是否位于循环体中
-    """
-    if tree is None:
-        tree, _ = parse_java(lines)
-
-    method_ctx: List[Optional[str]] = [None] * len(lines)
-    loop_ctx: List[bool] = [False] * len(lines)
-    
-    def walk(node, current_method=None, in_loop=False):
-        m_name = current_method
-        if node.type in ("method_declaration", "constructor_declaration"):
-            name_node = node.child_by_field_name("name")
-            if name_node:
-                m_name = name_node.text.decode('utf-8')
-        
-        is_loop = in_loop
-        if node.type in ("for_statement", "enhanced_for_statement", "while_statement", "do_statement"):
-            is_loop = True
-        elif node.type == "method_invocation":
-            name_node = node.child_by_field_name("name")
-            if name_node and name_node.text.decode('utf-8') in ("forEach", "map", "flatMap", "peek"):
-                is_loop = True
-
-        start_row = node.start_point[0]
-        end_row = node.end_point[0]
-        for r in range(start_row, end_row + 1):
-            if r < len(lines):
-                method_ctx[r] = m_name
-                if is_loop:
-                    loop_ctx[r] = True
-
-        for child in node.children:
-            walk(child, m_name, is_loop)
-            
-    walk(tree.root_node)
-    return method_ctx, loop_ctx
-
-
-# 操作插件的类标识模式
-OP_PLUGIN_MARKERS = [
-    r"extends\s+AbstractOperationServicePlugIn\b",
-    r"extends\s+AbstractOperationServicePlugInExt\b",
-    r"extends\s+AbstractValidatorExt\b",
-    r"implements\s+.*OperationServicePlugIn\b",
-]
-
-# UI 插件标识模式
-UI_PLUGIN_MARKERS = [
-    r"extends\s+AbstractFormPluginExt\b",
-    r"extends\s+AbstractBillPlugInExt\b",
-    r"extends\s+AbstractListPluginExt\b",
-    r"extends\s+AbstractFormPlugin\b",
-    r"extends\s+AbstractBillPlugIn\b",
-    r"extends\s+AbstractListPlugin\b",
-    r"extends\s+AbstractTreeListPlugin\b",
-    r"extends\s+StandardTreeListPlugin\b",
-]
-
-# 其他继承型插件标识模式（非操作、非 UI，但仍需检查 super 调用）
-OTHER_INHERITABLE_MARKERS = [
-    r"extends\s+AbstractConvertPlugIn\b",
-    r"extends\s+AbstractWriteBackPlugIn\b",
-    r"extends\s+AbstractReportFormPlugin\b",
-    r"extends\s+AbstractReportListDataPlugin\b",
-    r"extends\s+AbstractPrintPlugin\b",
-    r"extends\s+AbstractTask\b",
-    r"extends\s+BatchImportPlugin\b",
-]
-
-
-def detect_plugin_type(lines: List[str]) -> Tuple[bool, bool, bool]:
-    """检测文件是操作插件、UI 插件还是其他继承型插件，返回 (is_op, is_ui, is_other_inheritable)"""
-    full_text = "\n".join(lines)
-    is_op = any(re.search(p, full_text) for p in OP_PLUGIN_MARKERS)
-    is_ui = any(re.search(p, full_text) for p in UI_PLUGIN_MARKERS)
-    is_other = any(re.search(p, full_text) for p in OTHER_INHERITABLE_MARKERS)
-    return is_op, is_ui, is_other
-
-
-def _detect_plugin_kind(text: str) -> Optional[str]:
-    """基于类声明文本判断当前类属于哪种插件类型。"""
-    if any(re.search(p, text) for p in OP_PLUGIN_MARKERS):
-        return "op"
-    if any(re.search(p, text) for p in UI_PLUGIN_MARKERS):
-        return "ui"
-    if any(re.search(p, text) for p in OTHER_INHERITABLE_MARKERS):
-        return "other"
-    return None
-
-
-def analyze_plugin_context(lines: List[str]) -> List[Optional[str]]:
-    """
-    基于类声明与 brace 深度分析每一行所在的插件上下文：
-    - op: 操作插件类
-    - ui: UI 插件类
-    - other: 其他继承型插件类
-    - None: 非插件类 / 无插件上下文
-    """
-    contexts: List[Optional[str]] = [None] * len(lines)
-    brace_depth = 0
-    class_stack: List[Tuple[int, Optional[str]]] = []
-    pending_class_decl: List[str] = []
-
-    for i, line in enumerate(lines):
-        code = code_for_structure(line)
-        stripped = code.strip()
-        contexts[i] = class_stack[-1][1] if class_stack else None
-
-        if pending_class_decl:
-            if stripped:
-                pending_class_decl.append(stripped)
-            if "{" in stripped:
-                class_text = " ".join(pending_class_decl)
-                class_stack.append((brace_depth + 1, _detect_plugin_kind(class_text)))
-                pending_class_decl = []
-        elif CLASS_DECL_RE.search(stripped):
-            pending_class_decl = [stripped]
-            if "{" in stripped:
-                class_text = " ".join(pending_class_decl)
-                class_stack.append((brace_depth + 1, _detect_plugin_kind(class_text)))
-                pending_class_decl = []
-
-        brace_depth += code.count("{") - code.count("}")
-
-        while class_stack and brace_depth < class_stack[-1][0]:
-            class_stack.pop()
-
-    return contexts
-
-
-def detect_listener_interfaces(lines: List[str]) -> List[str]:
-    """检测文件实现了哪些 Listener 接口"""
-    listeners = []
-    for line in lines:
-        m = re.search(r"implements\s+(.+?)(?:\s*\{|$)", line)
-        if m:
-            ifaces = [s.strip() for s in m.group(1).split(",")]
-            listeners.extend(i for i in ifaces if "Listener" in i)
-    return listeners

package/vendor/kingdee-skills/ok-cosmic/scripts/lint/resource_check.py

@@ -1,176 +0,0 @@
-# -*- coding: utf-8 -*-
-"""资源管理检查 (RESOURCE-*) — 来源: coding-preferences.md"""
-
-import re
-from typing import List, Dict, Optional, Set, Tuple
-
-from .base import LintIssue, Severity, analyze_java_context, code_for_structure
-
-
-# 资源持有规则列表
-RESOURCE_RULES = [
-    {
-        "pattern": r"(private|protected|public)\s+(DataSet|InputStream|OutputStream|Connection|ResultSet)\s+\w+\s*;",
-        "rule_id": "RESOURCE-001",
-        "severity": Severity.WARNING,
-        "message": "插件成员变量不应持有 DataSet/InputStream 等资源对象，有序列化问题",
-        "fix_hint": "在方法内使用后立即关闭，不持有引用",
-    },
-    {
-        "pattern": r"static\s+(?!final\b)\w+\s+\w+\s*=",
-        "rule_id": "RESOURCE-002",
-        "severity": Severity.WARNING,
-        "message": "不应使用非 final 的 static 变量存储状态，多实例会冲突",
-        "fix_hint": "使用 PageCache 或实例变量",
-        "exclude_pattern": r"(static\s+final|static\s+\w+\s+[A-Z_]+\s*=|LogFactory|getLogger|Log\s+log)",
-    },
-    {
-        "pattern": r"static\s+final\s+String\s+\w+\s*=\s*ResManager\s*\.\s*loadKDString\s*\(",
-        "rule_id": "RESOURCE-003",
-        "severity": Severity.WARNING,
-        "message": "不要将 ResManager.loadKDString(...) 固化为 static final 常量，运行时语言切换会失效",
-        "fix_hint": "改为方法内实时调用 ResManager.loadKDString(...)",
-    },
-]
-
-DATASET_VAR_DECL_PATTERN = re.compile(r"\bDataSet\s+([A-Za-z_]\w*)\s*=")
-DATASET_CLOSE_PATTERN = re.compile(r"\b([A-Za-z_]\w*)\s*\.\s*close\s*\(")
-DATASET_TRY_WITH_RESOURCE_PATTERN = re.compile(r"\btry\s*\(\s*DataSet\s+([A-Za-z_]\w*)\s*=")
-DATASET_RETURN_PATTERN = re.compile(r"\breturn\s+([A-Za-z_]\w*)\s*;")
-
-
-def _collect_method_ranges(
-    method_context: List[Optional[str]], total: int
-) -> List[Tuple[Optional[str], int, int]]:
-    """从 method_context 收集连续同方法行范围 [(method_name, start, end), ...]。"""
-    ranges: List[Tuple[Optional[str], int, int]] = []
-    if not method_context:
-        return ranges
-    cur_method = method_context[0]
-    start = 0
-    for i in range(1, total):
-        if method_context[i] != cur_method:
-            ranges.append((cur_method, start, i))
-            cur_method = method_context[i]
-            start = i
-    ranges.append((cur_method, start, total))
-    return ranges
-
-
-def check(filepath: str, lines: List[str]) -> List[LintIssue]:
-    """执行资源管理检查，返回问题列表。"""
-    issues: List[LintIssue] = []
-    method_context, _ = analyze_java_context(lines)
-
-    # ── 逐行：RESOURCE-001 / 002 / 003（文件级即可） ──
-    for i, line in enumerate(lines):
-        lineno = i + 1
-        code_line = code_for_structure(line)
-        for rule in RESOURCE_RULES:
-            exclude = rule.get("exclude_pattern")
-            if exclude and re.search(exclude, code_line):
-                continue
-            if re.search(rule["pattern"], code_line):
-                issues.append(LintIssue(
-                    file=filepath, line=lineno,
-                    severity=rule["severity"],
-                    rule_id=rule["rule_id"],
-                    message=rule["message"],
-                    fix_hint=rule["fix_hint"],
-                    source_line=line.strip(),
-                ))
-
-    # ── RESOURCE-004：按方法级隔离追踪 DataSet 生命周期 ──
-    method_ranges = _collect_method_ranges(method_context, len(lines))
-    for method_name, m_start, m_end in method_ranges:
-        if method_name is None:
-            continue
-        _check_dataset_lifecycle(filepath, lines, m_start, m_end, issues)
-
-    return issues
-
-
-def _check_dataset_lifecycle(
-    filepath: str, lines: List[str], m_start: int, m_end: int,
-    issues: List[LintIssue],
-) -> None:
-    """在一个方法范围内追踪 DataSet 声明/关闭/消费状态。"""
-    dataset_vars: Dict[str, int] = {}        # name -> declaration line
-    closed_vars: Set[str] = set()
-    consumed_vars: Set[str] = set()
-    in_try_resource = False
-    try_paren_depth = 0
-    # 用于跨行消费检测：记录最近的 DataSet 声明变量名
-    pending_dataset_decl: Optional[str] = None
-
-    for i in range(m_start, m_end):
-        lineno = i + 1
-        code_line = code_for_structure(lines[i])
-
-        # ── 声明检测 ──
-        decl_match = DATASET_VAR_DECL_PATTERN.search(code_line)
-        if decl_match:
-            var_name = decl_match.group(1)
-            # 同方法内同名变量取最新声明行
-            dataset_vars[var_name] = lineno
-            pending_dataset_decl = var_name
-
-            # 同行 RHS 消费检测：DataSet result = ds1.union(ds2)
-            eq_idx = code_line.find("=", code_line.find(var_name))
-            if eq_idx >= 0:
-                rhs = code_line[eq_idx + 1:]
-                for tracked_var in list(dataset_vars):
-                    if tracked_var != var_name and re.search(
-                        rf"\b{re.escape(tracked_var)}\b", rhs
-                    ):
-                        consumed_vars.add(tracked_var)
-                        # 派生链传递：如果源被管理（在 try 块或已被标记为消费），派生变量同享管理
-                        if tracked_var in closed_vars or tracked_var in consumed_vars:
-                            consumed_vars.add(var_name)
-        else:
-            # ── 跨行消费检测：上一行 DataSet xxx = ds1，本行 .union(ds2) ──
-            if pending_dataset_decl and code_line.strip().startswith("."):
-                for tracked_var in list(dataset_vars):
-                    if tracked_var != pending_dataset_decl and re.search(
-                        rf"\b{re.escape(tracked_var)}\b", code_line
-                    ):
-                        consumed_vars.add(tracked_var)
-                        if tracked_var in closed_vars or tracked_var in consumed_vars:
-                            consumed_vars.add(pending_dataset_decl)
-            else:
-                pending_dataset_decl = None
-
-        # ── try-with-resources 检测 ──
-        if re.search(r"\btry\s*\(", code_line):
-            in_try_resource = True
-            
-        if in_try_resource:
-            try_paren_depth += code_line.count("(") - code_line.count(")")
-            for vn in DATASET_VAR_DECL_PATTERN.findall(code_line):
-                closed_vars.add(vn)
-            if try_paren_depth <= 0:
-                in_try_resource = False
-                try_paren_depth = 0
-
-        # ── .close() 检测 ──
-        for close_var in DATASET_CLOSE_PATTERN.findall(code_line):
-            closed_vars.add(close_var)
-
-        # ── return 消费检测 ──
-        return_match = DATASET_RETURN_PATTERN.search(code_line)
-        if return_match and return_match.group(1) in dataset_vars:
-            consumed_vars.add(return_match.group(1))
-
-    # ── 汇总本方法的 RESOURCE-004 ──
-    for var_name, decl_line in dataset_vars.items():
-        if var_name in closed_vars or var_name in consumed_vars:
-            continue
-        issues.append(LintIssue(
-            file=filepath,
-            line=decl_line,
-            severity=Severity.ERROR,
-            rule_id="RESOURCE-004",
-            message=f"检测到 DataSet 变量 `{var_name}` 但未发现 close() 调用，也未被 return 或后续 DataSet 计算消费",
-            fix_hint="在最靠近使用完成的位置调用 close()；若该 DataSet 是方法返回值或已参与计算/合并则无需关闭",
-            source_line=lines[decl_line - 1].strip(),
-        ))