Phần 1 — Sự sụp đổ của 'Thợ gõ code': Khi cú pháp không còn là lợi thế cạnh tranh

#!/usr/bin/env python3
"""
Production Tree-sitter AST Extraction & Complexity Analyzer
Phan tich cay cu phap AST cua ma nguon Go, trich xuat chu ky ham,
tinh toan do phuc tap Cyclomatic Complexity va tao prompt context cho AI Agent.
"""

from __future__ import annotations

import json
import logging
from dataclasses import asdict, dataclass, field
from pathlib import Path
from typing import Any

import tree_sitter_go as tsgo
from tree_sitter import Language, Node, Parser

logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
logger = logging.getLogger("ASTAnalyzer")

NGON_NGU_GO = Language(tsgo.language())


@dataclass
class DinhNghiaThamSo:
    ten: str
    kieu: str


@dataclass
class ChuKyHam:
    ten_ham: str
    receiver: str | None
    danh_sach_tham_so: list[DinhNghiaThamSo]
    kieu_tra_ve: list[str]
    do_phuc_tap_cyclomatic: int
    dong_bat_dau: int
    dong_ket_thuc: int
    la_exported: bool
    chu_thich: str | None


@dataclass
class TruongStruct:
    ten_truong: str
    kieu_du_lieu: str
    tag_json: str | None


@dataclass
class DinhNghiaStruct:
    ten_struct: str
    cac_truong: list[TruongStruct]
    dong_bat_dau: int
    dong_ket_thuc: int
    la_exported: bool


@dataclass
class NguCanhTepAST:
    duong_dan_tep: str
    ten_package: str
    danh_sach_import: list[str] = field(default_factory=list)
    danh_sach_struct: list[DinhNghiaStruct] = field(default_factory=list)
    danh_sach_ham: list[ChuKyHam] = field(default_factory=list)
    tong_do_phuc_tap: int = 0


class BoTrichXuatASTGo:
    """Trich xuat chu ky kien truc va chi so phuc tap tu ma nguon Go."""

    CAC_NUT_RE_NHANH = {
        "if_statement",
        "for_statement",
        "type_switch_statement",
        "expression_switch_statement",
        "communication_case",
        "default_case",
        "expression_case",
    }

    def __init__(self) -> None:
        self.parser = Parser()
        self.parser.language = NGON_NGU_GO

    def phan_tich_ma_nguon(self, duong_dan: str, du_lieu_bytes: bytes) -> NguCanhTepAST:
        cay_cu_phap = self.parser.parse(du_lieu_bytes)
        goc = cay_cu_phap.root_node

        ten_pkg = self._lay_ten_package(goc, du_lieu_bytes)
        ds_import = self._lay_danh_sach_import(goc, du_lieu_bytes)
        ds_struct = self._lay_danh_sach_struct(goc, du_lieu_bytes)
        ds_ham = self._lay_danh_sach_ham(goc, du_lieu_bytes)

        tong_phuc_tap = sum(h.do_phuc_tap_cyclomatic for h in ds_ham)

        return NguCanhTepAST(
            duong_dan_tep=duong_dan,
            ten_package=ten_pkg,
            danh_sach_import=ds_import,
            danh_sach_struct=ds_struct,
            danh_sach_ham=ds_ham,
            tong_do_phuc_tap=tong_phuc_tap,
        )

    def _lay_ten_package(self, goc: Node, source: bytes) -> str:
        for con in goc.children:
            if con.type == "package_clause":
                for sub in con.children:
                    if sub.type == "package_identifier":
                        return source[sub.start_byte : sub.end_byte].decode("utf-8")
        return "main"

    def _lay_danh_sach_import(self, goc: Node, source: bytes) -> list[str]:
        imports = []
        for con in goc.children:
            if con.type == "import_declaration":
                for spec in con.children:
                    if spec.type == "import_spec":
                        nut_path = spec.child_by_field_name("path")
                        if nut_path:
                            raw = source[nut_path.start_byte : nut_path.end_byte].decode("utf-8")
                            imports.append(raw.strip('"'))
                    elif spec.type == "import_spec_list":
                        for sub_spec in spec.children:
                            if sub_spec.type == "import_spec":
                                nut_path = sub_spec.child_by_field_name("path")
                                if nut_path:
                                    raw = source[nut_path.start_byte : nut_path.end_byte].decode("utf-8")
                                    imports.append(raw.strip('"'))
        return imports

    def _lay_danh_sach_struct(self, goc: Node, source: bytes) -> list[DinhNghiaStruct]:
        structs = []
        for con in goc.children:
            if con.type == "type_declaration":
                for spec in con.children:
                    if spec.type == "type_spec":
                        nut_ten = spec.child_by_field_name("name")
                        nut_kieu = spec.child_by_field_name("type")
                        if nut_ten and nut_kieu and nut_kieu.type == "struct_type":
                            ten_s = source[nut_ten.start_byte : nut_ten.end_byte].decode("utf-8")
                            cac_truong = self._phan_tich_truong_struct(nut_kieu, source)
                            structs.append(
                                DinhNghiaStruct(
                                    ten_struct=ten_s,
                                    cac_truong=cac_truong,
                                    dong_bat_dau=spec.start_point[0] + 1,
                                    dong_ket_thuc=spec.end_point[0] + 1,
                                    la_exported=ten_s[0].isupper(),
                                )
                            )
        return structs

    def _phan_tich_truong_struct(self, nut_struct: Node, source: bytes) -> list[TruongStruct]:
        danh_sach = []
        ds_fields = nut_struct.child_by_field_name("fields")
        if not ds_fields:
            return danh_sach

        for khai_bao in ds_fields.children:
            if khai_bao.type == "field_declaration":
                nut_ten = khai_bao.child_by_field_name("name")
                nut_kieu = khai_bao.child_by_field_name("type")
                nut_tag = khai_bao.child_by_field_name("tag")

                t_ten = source[nut_ten.start_byte : nut_ten.end_byte].decode("utf-8") if nut_ten else "an_danh"
                t_kieu = source[nut_kieu.start_byte : nut_kieu.end_byte].decode("utf-8") if nut_kieu else "khong_ro"
                t_tag = source[nut_tag.start_byte : nut_tag.end_byte].decode("utf-8") if nut_tag else None

                danh_sach.append(TruongStruct(ten_truong=t_ten, kieu_du_lieu=t_kieu, tag_json=t_tag))
        return danh_sach

    def _lay_danh_sach_ham(self, goc: Node, source: bytes) -> list[ChuKyHam]:
        danh_sach = []
        for con in goc.children:
            if con.type in ("function_declaration", "method_declaration"):
                ck = self._phan_tich_nut_ham(con, source)
                if ck:
                    danh_sach.append(ck)
        return danh_sach

    def _phan_tich_nut_ham(self, nut: Node, source: bytes) -> ChuKyHam | None:
        nut_ten = nut.child_by_field_name("name")
        if not nut_ten:
            return None

        ten_h = source[nut_ten.start_byte : nut_ten.end_byte].decode("utf-8")
        rec = None
        nut_rec = nut.child_by_field_name("receiver")
        if nut_rec:
            rec = source[nut_rec.start_byte : nut_rec.end_byte].decode("utf-8")

        tham_so = []
        nut_params = nut.child_by_field_name("parameters")
        if nut_params:
            for p in nut_params.children:
                if p.type == "parameter_declaration":
                    p_ten = p.child_by_field_name("name")
                    p_kieu = p.child_by_field_name("type")
                    pten = source[p_ten.start_byte : p_ten.end_byte].decode("utf-8") if p_ten else "_"
                    pkieu = source[p_kieu.start_byte : p_kieu.end_byte].decode("utf-8") if p_kieu else ""
                    tham_so.append(DinhNghiaThamSo(ten=pten, kieu=pkieu))

        kieu_tra_ve = []
        nut_ket_qua = nut.child_by_field_name("result")
        if nut_ket_qua:
            if nut_ket_qua.type == "parameter_list":
                for r in nut_ket_qua.children:
                    if r.type == "parameter_declaration":
                        r_kieu = r.child_by_field_name("type")
                        if r_kieu:
                            kieu_tra_ve.append(source[r_kieu.start_byte : r_kieu.end_byte].decode("utf-8"))
            else:
                kieu_tra_ve.append(source[nut_ket_qua.start_byte : nut_ket_qua.end_byte].decode("utf-8"))

        do_phuc_tap = self._tinh_do_phuc_tap_cyclomatic(nut, source)

        return ChuKyHam(
            ten_ham=ten_h,
            receiver=rec,
            danh_sach_tham_so=tham_so,
            kieu_tra_ve=kieu_tra_ve,
            do_phuc_tap_cyclomatic=do_phuc_tap,
            dong_bat_dau=nut.start_point[0] + 1,
            dong_ket_thuc=nut.end_point[0] + 1,
            la_exported=ten_h[0].isupper(),
            chu_thich=None,
        )

    def _tinh_do_phuc_tap_cyclomatic(self, nut: Node, source: bytes) -> int:
        """Tinh McCabe Cyclomatic Complexity: CC = Nut_Re_Nhanh + 1."""
        phuc_tap = 1

        def duyet(n: Node):
            nonlocal phuc_tap
            if n.type in self.CAC_NUT_RE_NHANH:
                phuc_tap += 1
            elif n.type == "binary_expression":
                op_node = n.child_by_field_name("operator")
                if op_node:
                    op_text = source[op_node.start_byte : op_node.end_byte].decode("utf-8")
                    if op_text in ("&&", "||"):
                        phuc_tap += 1
            for child in n.children:
                duyet(child)

        duyet(nut)
        return phuc_tap


def dong_goi_prompt_json(ngu_canh: NguCanhTepAST) -> str:
    """Dong goi ngu canh AST thanh JSON gon gang de truyen vao prompt cho AI."""
    du_lieu = {
        "tep_tin": ngu_canh.duong_dan_tep,
        "package": ngu_canh.ten_package,
        "imports": ngu_canh.danh_sach_import,
        "hop_dong_struct": [
            {
                "ten": s.ten_struct,
                "exported": s.la_exported,
                "cac_truong": [f"{t.ten_truong}: {t.kieu_du_lieu}" for t in s.cac_truong],
            }
            for s in ngu_canh.danh_sach_struct
        ],
        "chu_ky_giao_dien": [
            {
                "ten_ham": h.ten_ham,
                "receiver": h.receiver,
                "tham_so": [f"{p.ten}: {p.kieu}" for p in h.danh_sach_tham_so],
                "tra_ve": h.kieu_tra_ve,
                "do_phuc_tap": h.do_phuc_tap_cyclomatic,
                "dong": f"{h.dong_bat_dau}-{h.dong_ket_thuc}",
            }
            for h in ngu_canh.danh_sach_ham
        ],
        "chi_so_danh_gia": {
            "tong_so_ham": len(ngu_canh.danh_sach_ham),
            "tong_do_phuc_tap": ngu_canh.tong_do_phuc_tap,
            "canh_bao_rui_ro": "CAO" if ngu_canh.tong_do_phuc_tap > 20 else "BINH_THUONG",
        },
    }
    return json.dumps(du_lieu, indent=2, ensure_ascii=False)


if __name__ == "__main__":
    ma_nguon_go_mau = b"""
    package paymentservice

    import (
        "context"
        "errors"
        "time"
    )

    type PaymentOrder struct {
        OrderID   string    `json:"order_id"`
        Amount    float64   `json:"amount"`
        Currency  string    `json:"currency"`
        CreatedAt time.Time `json:"created_at"`
    }

    type OrderProcessor struct {
        maxRetries int
    }

    func (p *OrderProcessor) ProcessTransaction(ctx context.Context, order *PaymentOrder) (string, error) {
        if order == nil {
            return "", errors.New("nil order")
        }
        if order.Amount <= 0 || order.Currency == "" {
            return "", errors.New("invalid transaction parameters")
        }

        for attempt := 0; attempt < p.maxRetries; attempt++ {
            select {
            case <-ctx.Done():
                return "", ctx.Err()
            default:
                if order.Amount > 10000.0 {
                    return "FLAGGED_FOR_MANUAL_REVIEW", nil
                }
                return "SETTLED_OK", nil
            }
        }
        return "RETRY_EXHAUSTED", nil
    }
    """

    bo_trich_xuat = BoTrichXuatASTGo()
    ngu_canh = bo_trich_xuat.phan_tich_ma_nguon("payment_processor.go", ma_nguon_go_mau)
    json_ket_qua = dong_goi_prompt_json(ngu_canh)

    logger.info("Da trich xuat thanh cong cay cu phap AST voi Tree-sitter:")
    print(json_ket_qua)