kcode-pi 0.1.0

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

@@ -0,0 +1,393 @@
+# -*- 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

@@ -0,0 +1,176 @@
+# -*- 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(),
+        ))