Onboard-CLI คือเครื่องมือแบบพิมพ์คำสั่ง (command-line tool คือโปรแกรมที่สั่งงานด้วยการพิมพ์คำสั่ง ไม่ใช่กดปุ่ม) ที่อ่านโครงสร้างโค้ดทั้งโปรเจกต์แล้ววาดออกมาเป็นแผนผังให้ดูบนเครื่องตัวเอง ภายในไม่กี่นาที

ลองนึกถึงตอนเปิดโปรเจกต์ที่ไม่เคยแตะมาก่อน ไฟล์เป็นพัน โฟลเดอร์ซ้อนกันหลายชั้น กว่าจะรู้ว่าไฟล์ไหนเรียกไฟล์ไหน โมดูล (ก้อนโค้ดที่แยกเป็นส่วน ๆ) นี้พึ่งพาอะไรบ้าง ก็ไล่อ่านทีละไฟล์อยู่เป็นวัน Onboard-CLI ช่วยตัดขั้นตอนตรงนั้นออกไปด้วยการอ่านโครงสร้างโค้ดทุกไฟล์ แล้วประกอบเป็นภาพความสัมพันธ์ให้เห็นทั้งก้อนในหน้าจอเดียว ที่สำคัญ มันไม่ได้หยุดแค่วาดภาพ แต่ยังคอยเฝ้าไม่ให้โครงสร้างที่วางไว้ค่อย ๆ เพี้ยนไปตามเวลาด้วย

อ่านไวยากรณ์ของโค้ด ไม่ใช่เดาเอา

หลายคนพอได้ยินคำว่า "อ่านโค้ดทั้งโปรเจกต์" ก็นึกถึงแชตบอตที่เดาความหมายให้ แต่ Onboard-CLI ทำงานคนละแบบ มันไม่ได้รันโค้ดของเรา และไม่ได้ส่งโค้ดออกไปถามโมเดลภาษา

มันพาร์ส (อ่านแยกโครงสร้าง) โค้ดแต่ละไฟล์ให้กลายเป็น AST (โครงสร้างต้นไม้ที่แทนไวยากรณ์ของโค้ด) ผ่านเครื่องมือชื่อ Tree-sitter (ตัวอ่านไวยากรณ์ของภาษาโปรแกรม) เหมือนอ่านโครงสร้างประโยคของโค้ดทีละบรรทัด จากตรงนั้นมันจึงรู้ว่าไฟล์ไหน import (เรียกใช้) ไฟล์ไหน ฟังก์ชันไหนเรียกฟังก์ชันไหน โดยไม่ต้องเดาสักนิด

ข้อดีของวิธีนี้คือความแม่นยำ เพราะไวยากรณ์ของโค้ดมีคำตอบที่ตายตัว ไม่ใช่การประมาณเอา และตอนนี้มันรองรับถึง 5 ภาษาในตัว ทั้ง Go, TypeScript, JavaScript, Python และ Java

แผนผังที่เปิดดูบนเครื่องตัวเอง

พอสั่ง onboard map มันจะเปิดหน้าเว็บบนเครื่องเราเองที่ http://localhost:3000/app หน้าเว็บนี้เป็น canvas (พื้นที่วาดที่ลากดูได้) ซูมเข้าออกได้ และค้นหาไฟล์ด้วย Ctrl+P ได้ทันที ส่วนคำสั่งเต็ม ๆ อย่าง onboard map --target "internal/parser" --radius 2 หมายถึงให้มันเริ่มวาดจากจุดที่เราสนใจ แล้วไล่ความสัมพันธ์ออกไปกว้างกี่ชั้น (ค่าเริ่มต้นคือ 1 ชั้น)

ทั้งหมดนี้คือความหมายของคำว่า local-first (ทำงานจบบนเครื่องตัวเอง) ที่โปรเจกต์นี้ชูไว้ นั่นคือโค้ดของเราไม่ได้ออกไปไหนเลย ทุกอย่างรันอยู่บนเครื่องตัวเอง ไม่ใช่บริการบนคลาวด์ที่ต้องอัปโหลดโค้ดทั้งโปรเจกต์ขึ้นไปก่อน สำหรับโค้ดของบริษัทที่ห้ามหลุดออกนอกเครื่อง จุดนี้คือเรื่องใหญ่

จับตอนโครงสร้างเริ่มเพี้ยน

โค้ดเบส (codebase คือกองโค้ดทั้งหมดของโปรเจกต์) ที่ออกแบบมาสวยในวันแรก มักจะค่อย ๆ รวนเมื่อเวลาผ่านไป มีคน import ข้ามชั้นที่ไม่ควรข้าม มีโมดูลแอบไปพึ่งพากันแบบที่ไม่ได้ตั้งใจ อาการแบบนี้เรียกว่า architecture drift คือการที่โครงสร้างจริงค่อย ๆ เพี้ยนไปจากที่ออกแบบไว้

Onboard-CLI ให้เราเขียนกฎขอบเขตไว้ในไฟล์ architecture.yaml เช่น ชั้นไหนห้ามเรียกชั้นไหน แล้วสั่ง onboard drift เพื่อตรวจว่ามีใครแหกกฎบ้าง จุดที่น่าสนใจคือมันประเมินกฎพวกนี้ได้ในเวลาไม่ถึงวินาที แม้กับโค้ดที่มีไฟล์เป็นพัน ๆ

และเพราะมันเร็วขนาดนั้น จึงเอาไปฝังใน Git hooks (สคริปต์ที่รันอัตโนมัติเวลาเรา commit หรือ push โค้ด คือตอนบันทึกและส่งโค้ดขึ้นที่เก็บกลาง) หรือใน GitHub Actions (ระบบรันงานอัตโนมัติของ GitHub) ได้เลย ผลคือทุกครั้งที่มีคนเปิด Pull Request เพื่อขอรวมโค้ด ระบบจะเช็กให้อัตโนมัติว่าการแก้ครั้งนี้ทำให้โครงสร้างเพี้ยนไหม ถ้าเพี้ยนก็เตือนตั้งแต่ก่อนโค้ดจะรวมเข้าไป ไม่ใช่มารู้ตอนที่มันสายเกินแก้

เริ่มใช้จริงในไม่กี่คำสั่ง

ขั้นแรกคือติดตั้ง ตัวโปรแกรมมีสคริปต์ติดตั้งให้ทั้งฝั่ง macOS กับ Linux และฝั่ง Windows รันครั้งเดียวก็ได้คำสั่ง onboard มาใช้ จากนั้นสามคำสั่งแรกที่ทำให้เห็นผลเร็วที่สุดคือ

1. onboard init สร้างไฟล์ตั้งค่า .onboard ของโปรเจกต์ ถ้าอยากได้กฎสถาปัตยกรรมสำเร็จรูปก็ใส่แฟล็ก (flag คือตัวเลือกเสริมที่เติมท้ายคำสั่ง) --template ได้ เช่น clean-architecture, modular-monolith, mvc หรือ serverless
2. onboard map --target "..." --radius 2 เปิดแผนผังขึ้นมาดูบนเบราว์เซอร์
3. onboard drift --rules architecture.yml ตรวจว่าโครงสร้างยังตรงกับกฎที่วางไว้ไหม

แค่สามคำสั่งนี้ก็ครบทั้งเห็นภาพรวมและตรวจสอบแล้ว นอกจากนั้นยังมีคำสั่งเสริมที่หยิบใช้ตามงาน

• onboard routes สำหรับคนทำ backend (ฝั่งเซิร์ฟเวอร์หรือหลังบ้านของระบบ) ที่อยากรู้ว่า API (ช่องทางให้โปรแกรมคุยกัน) แต่ละเส้นวิ่งไปที่ไฟล์ไหน รองรับทั้ง Express, Gin, FastAPI และ Spring
• onboard impact สำหรับตอนกำลังจะแก้โค้ด อยากรู้ล่วงหน้าว่าจะกระทบส่วนไหนบ้าง
• onboard owners สำหรับตามหาว่าใครดูแลโค้ดส่วนไหน
• onboard pulse สำหรับดูสภาพโดยรวมของโค้ดเบสและความเคลื่อนไหวล่าสุดแบบเร็ว ๆ

ถ้ายังไม่รู้จะเริ่มตรงไหน ให้เริ่มจาก onboard map ก่อน เพราะการได้เห็นภาพรวมคือสิ่งที่คุ้มที่สุดในนาทีแรกที่เจอโปรเจกต์ที่ไม่คุ้นเคย

ของใหม่ที่ยังตัวเล็ก

ก่อนจะตื่นเต้นเกินไป มีสองเรื่องที่ควรรู้ไว้

เรื่องแรกคือโปรเจกต์ Onboard-CLI ยังใหม่และยังเล็กมาก บน GitHub มีดาวอยู่ 48 ดวง ออกมาแล้ว 9 รุ่น (ล่าสุดคือ v1.3.0) และมี animesh-94 (Animesh Yadav) เป็นผู้พัฒนาหลักอยู่คนเดียว ข้อดีคือมันเปิดซอร์สแบบ MIT ให้เอาไปลองได้ฟรี แต่ก็ต้องเผื่อใจว่ามันยังไม่ใช่เครื่องมือที่ผ่านสนามจริงในองค์กรใหญ่มานาน

เรื่องที่สองสำคัญกว่า คือมันวาด "โครงสร้าง" ให้เห็น แต่ไม่ได้เข้าใจ "เจตนา" ของโค้ดแทนเรา แผนผังบอกได้ว่าไฟล์ไหนเชื่อมกับไฟล์ไหน แต่ยังบอกไม่ได้ว่าทำไมโค้ดตรงนั้นถึงต้องเขียนแบบนั้น ส่วนกฎ drift จะแม่นแค่ไหนก็ขึ้นอยู่กับว่าเราเขียน architecture.yaml ไว้ดีแค่ไหน ถ้าเขียนกฎหลวม มันก็จับอะไรไม่ได้

แต่ต่อให้มันเข้าใจเจตนาแทนเราไม่ได้ การได้เห็นรูปร่างของโค้ดก่อนลงมือ ก็เปลี่ยนวิธีที่เราทำความรู้จักโปรเจกต์ที่ไม่คุ้นเคยไปคนละเรื่อง เพราะโค้ดที่มองเห็นรูปร่าง มักน่ากลัวน้อยกว่าโค้ดที่ต้องนั่งจินตนาการเอาเองในหัว

---

ที่มา: โปรเจกต์ Onboard-CLI โดย animesh-94 บน GitHub