feat(tools): STMATE 원본 DBF/SMT/STC/JB_R 직접 읽기·쓰기 브리지 서버 및 UI 연동 추가 (tools/stmate-test)

tools/stmate-test/server.py

@@ -0,0 +1,687 @@
+# -*- coding: utf-8 -*-
+"""STMATE 원본 DBF / SMT / STC / JB_R 직접 읽기·쓰기 연동 로컬 서버 (server.py)."""
+
+from __future__ import annotations
+
+import datetime
+import io
+import pathlib
+import re
+import shutil
+import struct
+import zipfile
+from decimal import Decimal, ROUND_DOWN
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel
+
+HERE = pathlib.Path(__file__).resolve().parent
+REPO_ROOT = HERE.parent.parent
+WORK_DBF_ROOT = HERE / "work_dbf"
+STMATE_ROOT = pathlib.Path(r"C:\경영정보(주)")
+STMATE_SYS_BSC = STMATE_ROOT / "System" / "ST_BSC"
+PRAC_DOCS_ROOT = REPO_ROOT / "resources" / "knowledge" / "original" / "실무문서"
+
+STRUCT_RE = re.compile(r"^(T\d|E\d|C\d|:)$")
+SMT_KV_RE = re.compile(r"([A-Za-z0-9_]+)=([^\r\n\x00]+)")
+
+app = FastAPI(title="STMATE DBF Direct Bridge")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+def parse_dbf_bytes(b: bytes) -> tuple[list[dict], list[dict], dict]:
+    """dBASE III/IV 바이트를 파싱하여 (필드정의, 레코드목록, 헤더메타) 반환."""
+    if len(b) < 32:
+        raise ValueError("DBF 헤더 길이 부족")
+    ver = b[0]
+    nrec, hlen, rlen = struct.unpack_from("<IHH", b, 4)
+    fields: list[dict] = []
+    off = 32
+    while off < len(b) and b[off] != 0x0D:
+        raw_name = b[off : off + 11].split(b"\x00", 1)[0]
+        name = raw_name.decode("cp949", "replace").strip()
+        ftype = chr(b[off + 11])
+        flen = b[off + 16]
+        fdec = b[off + 17]
+        fields.append(
+            {
+                "name": name,
+                "type": ftype,
+                "len": flen,
+                "dec": fdec,
+                "raw_desc": b[off : off + 32].hex(),
+            }
+        )
+        off += 32
+
+    rows: list[dict] = []
+    for i in range(nrec):
+        pos = hlen + i * rlen
+        if pos + rlen > len(b):
+            break
+        rec = b[pos : pos + rlen]
+        deleted = rec[0:1] == b"*"
+        row: dict = {"_recno": i, "_deleted": deleted}
+        cur = 1
+        for f in fields:
+            val_bytes = rec[cur : cur + f["len"]]
+            cur += f["len"]
+            row[f["name"]] = val_bytes.decode("cp949", "replace").strip()
+        if not deleted:
+            rows.append(row)
+
+    meta = {"version": ver, "hlen": hlen, "rlen": rlen, "header_tail_hex": b[off:hlen].hex()}
+    return fields, rows, meta
+
+
+def build_dbf_bytes(fields: list[dict], rows: list[dict], meta: dict | None = None) -> bytes:
+    """(필드정의, 레코드목록)을 STMATE 호환 CP949 고정폭 DBF 바이트로 직렬화."""
+    ver = (meta or {}).get("version", 0x03)
+    today = datetime.date.today()
+    nrec = len(rows)
+    rlen = 1 + sum(int(f["len"]) for f in fields)
+    tail_bytes = bytes.fromhex((meta or {}).get("header_tail_hex", "0d"))
+    if not tail_bytes or tail_bytes[0] != 0x0D:
+        tail_bytes = b"\x0d"
+    hlen = 32 + 32 * len(fields) + len(tail_bytes)
+
+    hdr = bytearray(32)
+    hdr[0] = ver
+    hdr[1] = today.year - 1900
+    hdr[2] = today.month
+    hdr[3] = today.day
+    struct.pack_into("<IHH", hdr, 4, nrec, hlen, rlen)
+
+    out = io.BytesIO()
+    out.write(hdr)
+    for f in fields:
+        if f.get("raw_desc"):
+            desc = bytearray(bytes.fromhex(f["raw_desc"]))
+            desc[16] = int(f["len"])
+            desc[17] = int(f.get("dec", 0))
+            out.write(desc)
+        else:
+            desc = bytearray(32)
+            nm_b = f["name"].encode("cp949", "replace")[:10]
+            desc[: len(nm_b)] = nm_b
+            desc[11] = ord((f.get("type") or "C")[0])
+            desc[16] = int(f["len"])
+            desc[17] = int(f.get("dec", 0))
+            out.write(desc)
+    out.write(tail_bytes)
+
+    for row in rows:
+        out.write(b"*" if row.get("_deleted") else b" ")
+        for f in fields:
+            flen = int(f["len"])
+            fdec = int(f.get("dec", 0))
+            ftype = f.get("type", "C")
+            raw_val = row.get(f["name"], "")
+            if ftype in ("N", "F"):
+                sval = str(raw_val).strip()
+                if sval == "" or sval == "None":
+                    sval = ""
+                else:
+                    try:
+                        num = float(sval)
+                        sval = f"{num:.{fdec}f}" if fdec > 0 else f"{int(round(num))}"
+                    except Exception:
+                        pass
+                enc = sval.encode("ascii", "replace")[:flen]
+                out.write(enc.rjust(flen, b" "))
+            else:
+                sval = "" if raw_val is None else str(raw_val)
+                enc = sval.encode("cp949", "replace")[:flen]
+                out.write(enc.ljust(flen, b" "))
+
+    out.write(b"\x1a")
+    return out.getvalue()
+
+
+def parse_prjlst_smt(b: bytes) -> dict[str, str]:
+    if len(b) <= 0x200:
+        return {}
+    txt = b[0x200:].decode("cp949", "replace")
+    return {k: v.strip() for k, v in SMT_KV_RE.findall(txt)}
+
+
+def update_prjlst_smt_bytes(orig_b: bytes, updates: dict[str, str | int | float]) -> bytes:
+    """PRJLST.SMT의 SIxMemo 헤더(0x200)를 보존하며 키=값 본문을 갱신."""
+    header = bytearray(orig_b[:0x200]) if len(orig_b) >= 0x200 else bytearray(b"\x00" * 0x200)
+    txt = orig_b[0x200:].decode("cp949", "replace") if len(orig_b) > 0x200 else ""
+    for k, v in updates.items():
+        pat = re.compile(rf"(^|\r?\n)({re.escape(k)}=)([^\r\n\x00]*)", re.M)
+        if pat.search(txt):
+            txt = pat.sub(rf"\g<1>\g<2>{v}", txt)
+        else:
+            txt += f"\r\n{k}={v}"
+    body_b = txt.encode("cp949", "replace")
+    return bytes(header) + body_b
+
+
+def fnum(val: object, default: float = 0.0) -> float:
+    try:
+        s = str(val or "").strip().replace(",", "")
+        return float(s) if s else default
+    except Exception:
+        return default
+
+
+def discover_sources() -> dict:
+    projects: list[dict] = []
+    if STMATE_ROOT.exists():
+        for costn in sorted(STMATE_ROOT.rglob("COSTN.DBF")):
+            pdir = costn.parent
+            projects.append(
+                {
+                    "id": str(pdir),
+                    "name": f"[PC 폴더] {pdir.name}",
+                    "path": str(pdir),
+                    "kind": "folder",
+                }
+            )
+        for stc in sorted(STMATE_ROOT.rglob("*.STC")):
+            projects.append(
+                {
+                    "id": str(stc),
+                    "name": f"[PC STC] {stc.name}",
+                    "path": str(stc),
+                    "kind": "stc",
+                }
+            )
+
+    if PRAC_DOCS_ROOT.exists():
+        for stc in sorted(PRAC_DOCS_ROOT.rglob("*.STC")):
+            projects.append(
+                {
+                    "id": str(stc),
+                    "name": f"[실무 STC] {stc.stem}",
+                    "path": str(stc),
+                    "kind": "stc",
+                }
+            )
+
+    if WORK_DBF_ROOT.exists():
+        for costn in sorted(WORK_DBF_ROOT.rglob("COSTN.DBF")):
+            pdir = costn.parent
+            projects.append(
+                {
+                    "id": str(pdir),
+                    "name": f"[작업본 DBF] {pdir.name}",
+                    "path": str(pdir),
+                    "kind": "work_folder",
+                }
+            )
+
+    jbr_files: list[dict] = []
+    if STMATE_SYS_BSC.exists():
+        for p in sorted(STMATE_SYS_BSC.glob("*.JB_R*")):
+            jbr_files.append(
+                {
+                    "name": p.name,
+                    "path": str(p),
+                    "ext": p.suffix.upper(),
+                    "size": p.stat().st_size,
+                }
+            )
+
+    return {"projects": projects, "jbr_files": jbr_files, "work_root": str(WORK_DBF_ROOT)}
+
+
+def read_project_files(source_path: str) -> dict[str, bytes]:
+    p = pathlib.Path(source_path)
+    if not p.exists():
+        raise HTTPException(status_code=404, detail=f"경로를 찾을 수 없음: {source_path}")
+    files: dict[str, bytes] = {}
+    if p.is_file() and p.suffix.upper() == ".STC":
+        with zipfile.ZipFile(p, "r") as zf:
+            for nm in zf.namelist():
+                files[pathlib.Path(nm).name.upper()] = zf.read(nm)
+    elif p.is_dir():
+        for fp in p.iterdir():
+            if fp.is_file():
+                files[fp.name.upper()] = fp.read_bytes()
+    else:
+        raise HTTPException(status_code=400, detail="지원하지 않는 경로 형식")
+    return files
+
+
+def convert_dbf_to_sim_state(
+    costn_rows: list[dict], boq_rows: list[dict], smt_kv: dict[str, str], prj_row: dict
+) -> dict:
+    """원본 COSTN.DBF / BOQ11~12.DBF / PRJLST.SMT 레코드를 시뮬레이터 state로 변환."""
+    resources: list[dict] = []
+    machines: list[dict] = []
+    san_items: list[dict] = []
+    ilwi_items: list[dict] = []
+
+    for r in costn_rows:
+        code = (r.get("CODE") or "").strip()
+        if not code:
+            continue
+        prefix = code[0].upper()
+        name = r.get("NAME") or code
+        spec = r.get("SIZE") or ""
+        unit = r.get("UNIT") or ""
+        t1, l1, m1, s1 = (
+            fnum(r.get("TAMT1")),
+            fnum(r.get("LAMT1")),
+            fnum(r.get("MAMT1")),
+            fnum(r.get("SAMT1")),
+        )
+        cands = [fnum(r.get(f"AMT_{i}1")) for i in range(1, 6)]
+        amt61 = fnum(r.get("AMT_61")) or t1
+
+        if prefix in ("M", "L", "S"):
+            kind = "노무비" if prefix == "L" else ("경비" if prefix == "S" else "재료비")
+            non_zero = [x for x in cands if x > 0]
+            is_min = bool(non_zero and abs(min(non_zero) - amt61) < 1e-4)
+            resources.append(
+                {
+                    "id": code,
+                    "code": code,
+                    "name": name,
+                    "spec": spec,
+                    "unit": unit,
+                    "kind": kind,
+                    "candidates": cands if any(cands) else [amt61, 0, 0, 0, 0],
+                    "adoptMode": "min" if is_min else "manual",
+                    "manualPrice": amt61,
+                    "convertHourly": False,
+                    "isUsd": (r.get("DOLLOR") or "").upper() == "T",
+                }
+            )
+        else:
+            # B(일위대가), D(단가산출), X(중기)도 내역서 직접 참조가 가능하도록 복합단가 보존
+            ilwi_items.append(
+                {
+                    "id": code,
+                    "code": code,
+                    "name": f"[{prefix}] {name}",
+                    "spec": spec,
+                    "unit": unit,
+                    "fixedM": m1,
+                    "fixedL": l1,
+                    "fixedS": s1,
+                    "lines": [],
+                }
+            )
+            # 고정 성분단가를 기초자원 참조행으로 연결하여 시뮬레이터에서 동일 단가 유지
+            for comp_tag, comp_kind, val in (
+                ("M", "재료비", m1),
+                ("L", "노무비", l1),
+                ("S", "경비", s1),
+            ):
+                if val > 0:
+                    res_id = f"{code}_{comp_tag}"
+                    resources.append(
+                        {
+                            "id": res_id,
+                            "code": res_id,
+                            "name": f"{name} ({comp_kind})",
+                            "spec": spec,
+                            "unit": unit,
+                            "kind": comp_kind,
+                            "candidates": [val, 0, 0, 0, 0],
+                            "adoptMode": "manual",
+                            "manualPrice": val,
+                            "convertHourly": False,
+                            "isUsd": False,
+                        }
+                    )
+                    ilwi_items[-1]["lines"].append(
+                        {"refId": res_id, "qty": 1.0, "halPercent": 0, "devd": False}
+                    )
+
+    # BOQ 제외금액 구역(C*) 판별 (16번 문서 §4.2)
+    excl_span: set[int] = set()
+    for i, r in enumerate(boq_rows):
+        bd = (r.get("BDCODE1") or "").strip()
+        if bd.startswith("C"):
+            end_code = r.get("ENDCODE")
+            start_idx = next(
+                (j for j, q in enumerate(boq_rows) if q.get("SORTCODE") == end_code), None
+            )
+            if start_idx is not None:
+                for k in range(min(start_idx, i), max(start_idx, i) + 1):
+                    excl_span.add(k)
+
+    boq_items: list[dict] = []
+    known_ids = {x["id"] for x in resources} | {x["id"] for x in ilwi_items}
+    for i, r in enumerate(boq_rows):
+        bd = (r.get("BDCODE1") or "").strip()
+        if not bd or STRUCT_RE.match(bd):
+            continue
+        q1 = fnum(r.get("QTY1"))
+        q2 = fnum(r.get("QTY2")) if r.get("QTY2") else q1
+        name1 = r.get("NAME1") or bd
+        if bd not in known_ids:
+            # BOQ 자체 단가를 가진 말단행이면 호표 자동 생성
+            m1, l1, s1 = fnum(r.get("MAMT1")), fnum(r.get("LAMT1")), fnum(r.get("SAMT1"))
+            lines = []
+            for ctag, ckind, cval in (("M", "재료비", m1), ("L", "노무비", l1), ("S", "경비", s1)):
+                if cval > 0:
+                    rid = f"{bd}_{ctag}"
+                    resources.append(
+                        {
+                            "id": rid,
+                            "code": rid,
+                            "name": f"{name1} ({ckind})",
+                            "spec": r.get("SIZE1") or "",
+                            "unit": r.get("UNIT1") or "",
+                            "kind": ckind,
+                            "candidates": [cval, 0, 0, 0, 0],
+                            "adoptMode": "manual",
+                            "manualPrice": cval,
+                            "convertHourly": False,
+                            "isUsd": False,
+                        }
+                    )
+                    lines.append({"refId": rid, "qty": 1.0, "halPercent": 0, "devd": False})
+            ilwi_items.append(
+                {
+                    "id": bd,
+                    "code": bd,
+                    "name": name1,
+                    "spec": r.get("SIZE1") or "",
+                    "unit": r.get("UNIT1") or "",
+                    "lines": lines,
+                }
+            )
+            known_ids.add(bd)
+
+        row_type = "normal"
+        if i in excl_span:
+            row_type = "gov_fee" if ("수수료" in name1 or fnum(r.get("S_AMT1")) > 0) else "gov_mat"
+
+        boq_items.append(
+            {
+                "id": f"BOQ_{i + 1}",
+                "code": bd,
+                "name": name1,
+                "refId": bd,
+                "rowType": row_type,
+                "qty": q1,
+                "changedQty": q2 if q2 > 0 else q1,
+                "_recno": r.get("_recno", i),
+            }
+        )
+
+    rates = {
+        "KANNO": fnum(smt_kv.get("1_R_KANNO"), 14.5),
+        "SANBO": fnum(smt_kv.get("1_R_SANBO"), 3.56),
+        "KOBO": fnum(smt_kv.get("1_R_KOBO"), 1.01),
+        "KUNBO": fnum(smt_kv.get("1_R_KUNBO"), 3.545),
+        "SLVBO": fnum(smt_kv.get("1_R_SLVBO"), 12.95),
+        "YUNBO": fnum(smt_kv.get("1_R_YUNBO"), 4.5),
+        "TBUGUM": fnum(smt_kv.get("1_R_TBUGUM"), 0.0),
+        "ANJUN": fnum(smt_kv.get("1_R_ANJUN"), 1.86),
+        "KITA": fnum(smt_kv.get("1_R_T_KITA"), 6.0),
+        "HWAN": fnum(smt_kv.get("1_R_HWAN"), 0.8),
+        "EQIP": fnum(smt_kv.get("1_R_EQIPSU"), 0.4),
+        "ILBAN": fnum(smt_kv.get("1_R_ILBAN"), 6.0),
+        "IYUN": fnum(smt_kv.get("1_R_IYUN"), 15.0),
+        "S_SUDO": fnum(smt_kv.get("1_R_S_SUDO"), 0.0),
+        "S_BOKRI": fnum(smt_kv.get("1_R_S_BOKRI"), 0.0),
+        "S_SOMO": fnum(smt_kv.get("1_R_S_SOMO"), 0.0),
+        "S_TONGSIN": fnum(smt_kv.get("1_R_S_TONGSIN"), 0.0),
+        "S_SEGUM": fnum(smt_kv.get("1_R_S_SEGUM"), 0.0),
+        "S_PEGI": fnum(smt_kv.get("1_R_S_PEGI"), 0.0),
+        "S_DOSEO": fnum(smt_kv.get("1_R_S_DOSEO"), 0.0),
+        "S_JIGUP": fnum(smt_kv.get("1_R_S_JIGUP"), 0.0),
+    }
+
+    jab_type = int(fnum(smt_kv.get("JAB_TYPE"), 0))
+    cal_actl = int(fnum(smt_kv.get("CAL_ACTL"), 0))
+    scheme = ("SA" if jab_type == 1 else "TA") if cal_actl == 1 else ("S" if jab_type == 1 else "T")
+    tot_jeol = -int(fnum(smt_kv.get("1_I_TOT_JEOL"), 3))
+
+    return {
+        "projectMeta": {
+            "pname": prj_row.get("PNAME", ""),
+            "pnum": prj_row.get("PNUM", ""),
+            "kOrd": int(fnum(prj_row.get("K_ORD"), 0)),
+        },
+        "sysConfig": {
+            "rxFormula": "1/8*16/12*25/20",
+            "condCodes": "L00008, L00009, L00010",
+            "usdRate1": 1350,
+            "usdRate2": 1400,
+            "useChangedUsd": False,
+            "ecdDigits": 0,
+            "chnMode": "total" if prj_row.get("CHAMT") == "T" else "bimok",
+            "optOrder": "SML",
+            "kOrdSim": {
+                "pclass": int(fnum(prj_row.get("PCLASS"), 7)),
+                "regMode": 7,
+                "flag": 0,
+                "currentK": int(fnum(prj_row.get("K_ORD"), 2)) or 2,
+            },
+        },
+        "resources": resources[:120],
+        "machines": machines,
+        "sanItems": san_items,
+        "ilwiItems": ilwi_items[:120],
+        "boqItems": boq_items,
+        "kanjubConfig": {
+            "scheme": scheme,
+            "indirectTruncDigits": 0,
+            "anjunBaseAdd": fnum(smt_kv.get("1_C_ANJUN_G"), 5349000),
+            "anjunGovVatExcluded": True,
+            "anjunCap12": True,
+            "vatMode": "supply_10",
+            "totJeolDigits": tot_jeol,
+            "enableProfitEndAdj": True,
+            "govRoundMode": "up",
+            "govRoundDigits": -int(fnum(smt_kv.get("1_I_KWN_JEOLSA"), 3)),
+            "rates": rates,
+            "revModes": {
+                "KANNO": "recalculated",
+                "SANBO": "recalculated",
+                "KOBO": "recalculated",
+                "KUNBO": "carry_original",
+                "SLVBO": "carry_original",
+                "YUNBO": "carry_original",
+                "TBUGUM": "recalculated",
+                "ANJUN": "recalculated",
+                "KITA": "recalculated",
+                "HWAN": "recalculated",
+                "EQIP": "recalculated",
+            },
+        },
+    }
+
+
+class LoadReq(BaseModel):
+    source_path: str
+
+
+class LoadJbrReq(BaseModel):
+    jbr_path: str
+
+
+class SaveDbfReq(BaseModel):
+    source_path: str
+    target_folder_name: str = "stmate_edited"
+    costn_updates: list[dict] = []
+    boq_updates: list[dict] = []
+    prjlst_updates: dict = {}
+    smt_updates: dict = {}
+
+
+@app.get("/api/sources")
+def api_sources():
+    return discover_sources()
+
+
+@app.post("/api/load")
+def api_load(req: LoadReq):
+    files = read_project_files(req.source_path)
+    if "COSTN.DBF" not in files:
+        raise HTTPException(status_code=400, detail="COSTN.DBF 파일이 포함되지 않은 경로임")
+
+    costn_flds, costn_rows, _ = parse_dbf_bytes(files["COSTN.DBF"])
+    boq_name = "BOQ12.DBF" if "BOQ12.DBF" in files else "BOQ11.DBF"
+    boq_flds, boq_rows, _ = parse_dbf_bytes(files[boq_name]) if boq_name in files else ([], [], {})
+    prj_flds, prj_rows, _ = (
+        parse_dbf_bytes(files["PRJLST.DBF"]) if "PRJLST.DBF" in files else ([], [{}], {})
+    )
+    smt_kv = parse_prjlst_smt(files.get("PRJLST.SMT", b""))
+
+    rate_r_rows = []
+    if "RATE_R.DBF" in files:
+        _, rate_r_rows, _ = parse_dbf_bytes(files["RATE_R.DBF"])
+
+    sim_state = convert_dbf_to_sim_state(
+        costn_rows, boq_rows, smt_kv, prj_rows[0] if prj_rows else {}
+    )
+    return {
+        "source_path": req.source_path,
+        "boq_table_name": boq_name,
+        "file_list": sorted(files.keys()),
+        "prjlst": prj_rows[0] if prj_rows else {},
+        "prjlst_smt": smt_kv,
+        "costn_count": len(costn_rows),
+        "costn_rows": costn_rows[:200],
+        "boq_count": len(boq_rows),
+        "boq_rows": boq_rows[:200],
+        "rate_r_count": len(rate_r_rows),
+        "sim_state": sim_state,
+    }
+
+
+@app.post("/api/load-jbr")
+def api_load_jbr(req: LoadJbrReq):
+    p = pathlib.Path(req.jbr_path)
+    if not p.exists():
+        raise HTTPException(status_code=404, detail=f"JB_R 파일 없음: {req.jbr_path}")
+    flds, rows, _ = parse_dbf_bytes(p.read_bytes())
+    matrix: list[list[float]] = []
+    for r in rows:
+        matrix.append([fnum(r.get(f["name"])) for f in flds])
+
+    def cell(row_idx: int, col_1based: int, default: float = 0.0) -> float:
+        if 0 <= row_idx < len(matrix) and 0 <= col_1based - 1 < len(matrix[row_idx]):
+            return matrix[row_idx][col_1based - 1]
+        return default
+
+    raw_base = cell(20, 18, 5349.0)
+    anjun_base = raw_base * 1000 if 0 < raw_base < 100000 else raw_base
+    extracted_rates = {
+        "KANNO": cell(20, 1, 14.5),
+        "KITA": cell(20, 6, 6.0),
+        "ILBAN": cell(20, 11, 6.0),
+        "SANBO": cell(45, 1, 3.56),
+        "KOBO": cell(45, 17, 1.01),
+        "KUNBO": cell(46, 1, 3.545),
+        "YUNBO": cell(46, 6, 4.5),
+        "SLVBO": cell(46, 11, 12.95),
+        "IYUN": cell(20, 16, 15.0),
+        "ANJUN": cell(20, 17, 1.86),
+        "anjunBaseAdd": anjun_base,
+    }
+    return {
+        "name": p.name,
+        "row_count": len(matrix),
+        "col_count": len(flds),
+        "extracted_rates": extracted_rates,
+        "preview_rows": {
+            "row6_kanno_kita": matrix[6][:12] if len(matrix) > 6 else [],
+            "row20_iyun_anjun": matrix[20][:20] if len(matrix) > 20 else [],
+            "row45_sanbo_kobo": matrix[45][:20] if len(matrix) > 45 else [],
+            "row46_kunbo_yunbo_slvbo": matrix[46][:15] if len(matrix) > 46 else [],
+        },
+    }
+
+
+@app.post("/api/save")
+def api_save(req: SaveDbfReq):
+    files = read_project_files(req.source_path)
+    safe_name = re.sub(r"[^\w\-가-힣]", "_", req.target_folder_name or "stmate_edited").strip("_")
+    out_dir = WORK_DBF_ROOT / (safe_name or "stmate_edited")
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    # 1. COSTN.DBF 수정 반영 및 직렬화
+    if "COSTN.DBF" in files:
+        flds, rows, meta = parse_dbf_bytes(files["COSTN.DBF"])
+        upd_map = {str(u.get("CODE", "")).strip(): u for u in req.costn_updates if u.get("CODE")}
+        for r in rows:
+            cd = (r.get("CODE") or "").strip()
+            if cd in upd_map:
+                for k, v in upd_map[cd].items():
+                    if k in r:
+                        r[k] = str(v)
+        files["COSTN.DBF"] = build_dbf_bytes(flds, rows, meta)
+
+    # 2. BOQ11/12.DBF 수량·단가·비목금액 재계산 및 직렬화
+    boq_name = "BOQ12.DBF" if "BOQ12.DBF" in files else "BOQ11.DBF"
+    if boq_name in files:
+        flds, rows, meta = parse_dbf_bytes(files[boq_name])
+        upd_by_rec = {int(u["_recno"]): u for u in req.boq_updates if "_recno" in u}
+        for r in rows:
+            rno = int(r.get("_recno", -1))
+            if rno in upd_by_rec:
+                u = upd_by_rec[rno]
+                for k in ("NAME1", "QTY1", "MAMT1", "LAMT1", "SAMT1", "TAMT1"):
+                    if k in u and k in r:
+                        r[k] = str(u[k])
+                # 비목별 금액 ROUNDDOWN(QTY1 * 단가) 동기화
+                q = Decimal(str(fnum(r.get("QTY1"))))
+                m_u = Decimal(str(fnum(r.get("MAMT1"))))
+                l_u = Decimal(str(fnum(r.get("LAMT1"))))
+                s_u = Decimal(str(fnum(r.get("SAMT1"))))
+                m_a = int((q * m_u).quantize(Decimal(1), rounding=ROUND_DOWN))
+                l_a = int((q * l_u).quantize(Decimal(1), rounding=ROUND_DOWN))
+                s_a = int((q * s_u).quantize(Decimal(1), rounding=ROUND_DOWN))
+                r["M_AMT1"] = str(m_a)
+                r["L_AMT1"] = str(l_a)
+                r["S_AMT1"] = str(s_a)
+                r["T_AMT1"] = str(m_a + l_a + s_a)
+        files[boq_name] = build_dbf_bytes(flds, rows, meta)
+
+    # 3. PRJLST.DBF 및 PRJLST.SMT 갱신
+    if "PRJLST.DBF" in files and req.prjlst_updates:
+        flds, rows, meta = parse_dbf_bytes(files["PRJLST.DBF"])
+        if rows:
+            for k, v in req.prjlst_updates.items():
+                if k in rows[0]:
+                    rows[0][k] = str(v)
+        files["PRJLST.DBF"] = build_dbf_bytes(flds, rows, meta)
+
+    if "PRJLST.SMT" in files and req.smt_updates:
+        files["PRJLST.SMT"] = update_prjlst_smt_bytes(files["PRJLST.SMT"], req.smt_updates)
+
+    # 4. 폴더 내 개별 DBF/SMT 저장 및 .STC 패키지 생성
+    written_files = []
+    for fname, content in files.items():
+        fp = out_dir / fname
+        fp.write_bytes(content)
+        written_files.append({"name": fname, "size": len(content)})
+
+    stc_path = WORK_DBF_ROOT / f"{out_dir.name}.STC"
+    with zipfile.ZipFile(stc_path, "w", compression=zipfile.ZIP_DEFLATED) as zf:
+        for fname, content in files.items():
+            zf.writestr(fname, content)
+
+    return {
+        "ok": True,
+        "saved_dir": str(out_dir),
+        "saved_stc": str(stc_path),
+        "stc_size": stc_path.stat().st_size,
+        "written_count": len(written_files),
+        "written_files": written_files,
+    }
+
+
+app.mount("/", StaticFiles(directory=str(HERE), html=True), name="static")
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(app, host="127.0.0.1", port=8095)