Thanawat Wongchai

Posted on Jul 10 • Originally published at apidog.com

สุดยอดเครื่องมือ CLI สำหรับ AI Agents

เอเจนต์ AI ไม่ได้อ่าน GUI แต่รันคำสั่ง อ่านข้อมูลจาก stdout ตรวจสอบ exit code แล้วตัดสินใจขั้นถัดไป วงจรนี้จะเชื่อถือได้ก็ต่อเมื่อ CLI ให้ผลลัพธ์ที่คาดเดาได้ เครื่องมือที่พิมพ์ตารางสีสันสำหรับมนุษย์ ถามยืนยันแบบ y/n หรือคืน exit code เป็น 0 แม้งานล้มเหลว จะทำให้ automation ของเอเจนต์พังและแก้ปัญหาได้ยาก

ลองใช้ Apidog วันนี้

ดังนั้นคำถามสำคัญไม่ใช่ “CLI ตัวไหนเร็วที่สุด” แต่คือ “CLI ตัวไหนออกแบบมาให้เอเจนต์ดำเนินการกับเอาต์พุตได้” สำหรับ workflow แบบ agentic ให้มองหาสามอย่าง: JSON ที่มีโครงสร้าง, โหมด non-interactive ที่ไม่หยุดรอ input และ exit code ที่ใช้ตัดสินใจได้

บทความนี้แบ่ง CLI เป็น 2 กลุ่ม:

Agent runtimes: CLI ที่เป็นเอเจนต์เอง เช่น Claude Code, Codex CLI, Gemini CLI และ Cursor CLI
Tool CLIs: เครื่องมือที่เอเจนต์เรียกใช้เพื่อทำงาน เช่น gh, ripgrep, jq, HTTPie และ apidog-cli

หากคุณกำลังเชื่อมต่อเอเจนต์กับ workflow ของ API ให้ดู คู่มือ Apidog CLI ฉบับสมบูรณ์ สำหรับขั้นตอนติดตั้งและตัวอย่างการใช้งานจริง

อะไรที่ทำให้ CLI เหมาะสำหรับเอเจนต์ AI

ก่อนนำ CLI เข้า CI, cron job หรือ agent loop ให้ตรวจสอบคุณสมบัติ 3 ข้อนี้

1. Structured output

เอเจนต์วิเคราะห์ JSON ได้เชื่อถือได้กว่าการแยกตารางหรือข้อความที่จัดรูปแบบสำหรับมนุษย์ เลือกเครื่องมือที่มี --json, --output-format json หรือ JSONL สำหรับ event stream

gh pr list --json number,title,author

เมื่อได้ JSON เอเจนต์สามารถอ้างอิงฟิลด์ตามชื่อ เช่น .number หรือ .author.login แทนการเดาตำแหน่งคอลัมน์

2. Non-interactive mode

คำสั่งที่หยุดถามคำถามจะทำให้เอเจนต์แบบ headless ค้างได้ ใช้ flag เช่น -p, --non-interactive, --yes หรือโหมด batch เมื่อมีให้ใช้งาน

gemini --non-interactive -p "summarize this repository"

ทดสอบคำสั่งใน environment เดียวกับ CI เสมอ เพื่อยืนยันว่าไม่มี prompt แอบแฝง เช่น การยืนยันสิทธิ์หรือการยอมรับการเขียนไฟล์

3. Deterministic exit codes

exit code ต้องสื่อความหมายอย่างสม่ำเสมอ:

0: สำเร็จ
ไม่ใช่ 0: ล้มเหลว

ตัวอย่าง shell guard สำหรับหยุด pipeline เมื่อการทดสอบล้มเหลว:

apidog run || {
  echo "API tests failed"
  exit 1
}

คะแนนพิเศษคือเครื่องมือที่บอกเอเจนต์ได้ว่าควรทำอะไรต่อไป ซึ่งเป็นจุดที่ apidog-cli แตกต่างจาก CLI ทั่วไป

Claude Code

Claude Code คือเอเจนต์เขียนโค้ดของ Anthropic ที่ทำงานในเทอร์มินัล ใช้ -p เพื่อสั่งงานแบบ non-interactive แล้วรับผลลัพธ์ผ่าน stdout

npm install -g @anthropic-ai/claude-code

claude -p "summarize the failing tests in this repo" \
  --output-format json

--output-format json ส่ง payload แบบมีโครงสร้าง ซึ่งมีผลลัพธ์, session_id และ total_cost_usd ทำให้สคริปต์สามารถเก็บต้นทุนต่อการรันได้

หากต้องการรับเหตุการณ์ระหว่างทำงาน ใช้ stream-json พร้อม --verbose:

claude -p "fix the failing tests" \
  --verbose \
  --output-format stream-json

คุณยังส่งข้อมูลเข้าผ่าน pipe ได้:

cat build-error.txt | claude -p "explain this error"

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

ข้อจำกัด: เป็นโมเดลแบบปิดที่ต้องชำระเงินผ่าน API และค่าใช้จ่ายอาจเพิ่มขึ้นในการรันอัตโนมัติระยะยาว

Codex CLI

Codex CLI คือเอเจนต์เทอร์มินัลโอเพนซอร์สของ OpenAI ใช้ codex exec หรือ codex e สำหรับการรันแบบไม่โต้ตอบ

npm install -g @openai/codex

codex exec --json "add input validation to the signup handler"

--json เปลี่ยน stdout เป็น JSONL โดยแต่ละ event เช่น การรันคำสั่ง การแก้ไขไฟล์ หรือข้อความจากเอเจนต์ จะเป็น JSON object แยกกัน

ใช้ jq เพื่อดึง event ที่ต้องการ:

codex exec --json "fix lint errors" \
  | jq 'select(.type == "message")'

หาก workflow ต้องการผลลัพธ์สุดท้ายที่มี schema แน่นอน ให้ใช้ --output-schema เพื่อบังคับให้ผลลัพธ์เป็นไปตาม JSON Schema ที่กำหนด

เหมาะที่สุดสำหรับ: การแก้ไขโค้ดใน CI ที่ต้องการผลลัพธ์มี type และตรวจสอบ schema ได้

ข้อจำกัด: JSONL event stream มีรายละเอียดมาก จึงมักต้องใช้ jq กรองข้อมูลก่อนนำไปใช้จริง และควรทดสอบ --output-schema กับ prompt จริงของคุณ

Gemini CLI

Gemini CLI คือเอเจนต์เทอร์มินัลโอเพนซอร์สของ Google โดยจะเข้าโหมด headless อัตโนมัติเมื่ออยู่ใน non-TTY หรือเมื่อส่ง prompt ด้วย -p / --prompt

npm install -g @google/gemini-cli

gemini --non-interactive \
  --output-format json \
  -p "list the public endpoints in this service"

ใช้ --non-interactive เพื่อให้คำสั่งไม่หยุดรอ prompt และใช้ --output-format json เพื่อรับ response และสถิติการใช้งานเป็น JSON object เดียว

ตัวอย่างการดึงเฉพาะ response:

gemini --non-interactive \
  --output-format json \
  -p "summarize this codebase" \
  | jq -r '.response'

เหมาะที่สุดสำหรับ: ทีมที่อยู่ใน Google stack อยู่แล้ว และงานเน้นการอ่าน เช่น สรุปหรือรีวิว codebase

ข้อจำกัด: JSON output เป็นความสามารถที่เพิ่มเข้ามาภายหลังในบางส่วนของ ecosystem ดังนั้นควร pin เวอร์ชันและตรวจสอบเอกสารก่อนใช้งานใน production

Cursor CLI

cursor-agent นำเอเจนต์ของ Cursor มาใช้จากเทอร์มินัลโดยไม่ต้องเปิด editor ใช้ -p หรือ --print สำหรับ headless execution

curl https://cursor.com/install -fsS | bash

cursor-agent -p "refactor utils/date.js to use date-fns" \
  --output-format json

--output-format รองรับ text, json และ stream-json

json: รับ JSON object เดียวเมื่อรันเสร็จ
stream-json: รับ event ระหว่างรัน
text: เหมาะกับการอ่านโดยมนุษย์มากกว่า

สำหรับงานที่ต้องแก้ไขไฟล์หรือเรียก shell แบบไม่หยุดถาม ให้ใช้ --trust อย่างระมัดระวัง

cursor-agent -p "fix the failing unit tests" \
  --trust \
  --output-format json

เหมาะที่สุดสำหรับ: ทีมที่ใช้ Cursor อยู่แล้วและต้องการใช้เอเจนต์เดียวกันใน editor, CI และ git hooks

ข้อจำกัด: มีรายงานว่าโหมด headless -p ค้างในบาง build และบางแพลตฟอร์ม ควรทดสอบบน OS เป้าหมาย, pin เวอร์ชันที่เสถียร และใช้ token ที่มีสิทธิ์ต่ำที่สุด

gh (GitHub CLI)

gh คือ CLI หลักสำหรับงาน GitHub เช่น repository, issue, pull request และ release จุดสำคัญสำหรับเอเจนต์คือ --json

brew install gh

gh pr list --json number,title,author \
  --jq '.[].author.login'

ระบุฟิลด์ที่ต้องการผ่าน --json และกรองต่อด้วย --jq โดยไม่ต้องติดตั้ง jq เพิ่มในกรณีง่าย ๆ

หากต้องการตรวจสอบ field ที่ใช้ได้สำหรับคำสั่งนั้น ให้เรียกโดยไม่ระบุค่า:

gh pr list --json

สำหรับ API ที่คำสั่งย่อยยังไม่รองรับ ใช้ gh api เพื่อเรียก GitHub REST หรือ GraphQL API และรับ JSON ที่ถอดรหัสแล้ว

gh api repos/OWNER/REPO/pulls --jq '.[].title'

เหมาะที่สุดสำหรับ: งาน GitHub ทุกประเภทใน workflow ของเอเจนต์ ตั้งแต่ตรวจสอบสถานะ PR ไปจนถึงเปิด issue

ข้อจำกัด: ใช้ได้กับ GitHub เท่านั้น และ field ของ --json แตกต่างกันไปในแต่ละคำสั่งย่อย

ripgrep

ripgrep หรือ rg ช่วยให้เอเจนต์ค้นหา codebase ได้เร็ว สำหรับ workflow ที่ต้อง parse ผลลัพธ์ ให้ใช้ --json

brew install ripgrep

rg --json "TODO" src/ \
  | jq 'select(.type == "match") | .data.path.text'

แต่ละ event จะมี type เช่น begin, match, end หรือ summary โดย event ประเภท match มีข้อมูลเส้นทางไฟล์ หมายเลขบรรทัด และข้อความที่ตรงกันในฟิลด์ที่มีโครงสร้าง

แนวทางนี้ปลอดภัยกว่าการ parse ข้อความรูปแบบ file:line:text ซึ่งอาจพังได้เมื่อ path หรือข้อความมีเครื่องหมายโคลอน

เหมาะที่สุดสำหรับ: ค้นหาโค้ดแบบมีโครงสร้างใน repository ขนาดใหญ่ ก่อนตัดสินใจว่าจะตรวจสอบหรือแก้ไขไฟล์ใด

ข้อจำกัด: JSON output มีรายละเอียดมากและมักต้องใช้ jq; สำหรับการค้นหาครั้งเดียวแบบเร็ว ๆ plain text อาจง่ายกว่า

jq

jq คือเครื่องมือเชื่อม pipeline ของ CLI แบบ JSON เอเจนต์สามารถใช้มันเพื่อเลือก กรอง และปรับโครงสร้างข้อมูลก่อนส่งต่อไปยังคำสั่งถัดไป

brew install jq

curl -s https://api.github.com/repos/cli/cli \
  | jq '{name, stars: .stargazers_count}'

ตัวอย่าง pipeline ที่อ่าน PR title แล้วส่งให้เอเจนต์สรุป:

gh pr list --json number,title \
  | jq -r '.[] | "\(.number): \(.title)"' \
  | claude -p "summarize these pull requests"

jq จะคืน exit code ที่ไม่ใช่ศูนย์เมื่อ parse JSON ไม่ได้ ซึ่งช่วยให้ pipeline ตรวจพบ response ที่ผิดรูปแบบแทนที่จะส่งต่อข้อมูลเสีย ๆ ไปเงียบ ๆ

เหมาะที่สุดสำหรับ: แปลง JSON จาก CLI ใดก็ได้ให้เป็นรูปแบบที่ขั้นตอนถัดไปต้องการ

ข้อจำกัด: ต้องเรียนรู้ query language และรองรับเฉพาะ JSON จึงควรจับคู่กับเครื่องมือที่ให้ structured output

HTTPie

เมื่อเอเจนต์ต้องเรียก HTTP API โดยตรง HTTPie (http) มักใช้ง่ายกว่า curl เพราะออกแบบให้ทำงานกับ JSON เป็นหลัก

brew install httpie

http --print=b POST httpbin.org/post \
  name=apidog \
  role=cli

flag --print ควบคุมสิ่งที่ออกไปยัง stdout:

b: response body เท่านั้น
ใช้เมื่อเอเจนต์ต้อง parse JSON โดยไม่ต้องตัด header ออกก่อน

ตัวอย่างอ่าน field จาก API response:

http --print=b GET https://api.github.com/repos/cli/cli \
  | jq '{name, stars: .stargazers_count}'

การส่ง request body แบบ key=value ช่วยให้เอเจนต์สร้าง JSON request ได้โดยไม่ต้องประกอบ JSON string เอง

เหมาะที่สุดสำหรับ: API call แบบครั้งเดียวหรือ scripted call ที่ JSON input/output เป็นรูปแบบหลัก

ข้อจำกัด: เป็น dependency เพิ่มเติม ในขณะที่ curl มีอยู่แล้วบนหลายระบบ และ curl ยังเหมาะกว่าเมื่อใช้ protocol หรือ streaming ที่เฉพาะทาง

apidog-cli

CLI หลายตัวในรายการนี้เริ่มจากการเป็นเครื่องมือสำหรับมนุษย์ แล้วจึงเพิ่ม --json ในภายหลัง แต่ apidog-cli ออกแบบให้ผลลัพธ์เป็น structured JSON และมี agentHints.nextSteps เพื่อบอกเอเจนต์ว่าควรทำอะไรต่อไป

apidog-cli ครอบคลุมงาน API project แบบครบวงจร ไม่ใช่เพียง test runner เดียว โดยจัดการ endpoints, schemas, mocks, environments, import/export, เอกสาร, test scenarios และ branches ได้จาก CLI เดียว

ติดตั้งและยืนยันตัวตน:

npm install -g apidog-cli

apidog login --with-token <YOUR_TOKEN>
apidog run --help

จุดสำคัญสำหรับ automation คือ apidog run คืนค่า:

0 เมื่อทุก test ผ่าน
ไม่ใช่ 0 เมื่อมี test ล้มเหลว

ดังนั้น agent หรือ CI สามารถตัดสินใจจาก exit code ได้ทันที

apidog run

if [ $? -ne 0 ]; then
  echo "API test run failed"
  exit 1
fi

JSON response ยังมีคำแนะนำขั้นถัดไปสำหรับ agent ที่ต้อง orchestrate workflow ต่อเนื่อง ลดความจำเป็นในการเขียน glue code เพื่อวางลำดับคำสั่งเอง

ตัวอย่างการใช้งานร่วมกับ agent runtimes:

แยกพื้นที่แก้ไขของเอเจนต์ด้วย AI Branch

เอเจนต์ที่มีสิทธิ์เขียนใน API project อาจเขียนทับหรือลบ endpoint และ schema จริงได้ ใช้ AI Branch เพื่อให้เอเจนต์แก้ไขใน branch ที่แยกออกมา

apidog branch --type ai

branch ต้นฉบับจะไม่ถูกแก้ไขจนกว่าคุณจะอนุมัติ merge request

อ่านเพิ่มเติม:

เหมาะที่สุดสำหรับ: ให้เอเจนต์ใช้ CLI แบบ JSON-native ตัวเดียวสำหรับวงจรชีวิต API พร้อม next-step hints และพื้นที่แก้ไขที่แยกออกมา

ข้อจำกัด: Apidog ไม่ใช่โอเพนซอร์ส เป็นผลิตภัณฑ์เชิงพาณิชย์ที่มีเวอร์ชันฟรี และไม่มี OpenAPI linter ในตัว หาก workflow ต้องบังคับใช้ API style ให้จับคู่กับ Spectral หรือ Redocly

วิธีเลือก

ไม่มี CLI ตัวเดียวที่ชนะทุกงาน ให้เลือกรันไทม์หนึ่งตัวเพื่อขับเคลื่อน agent loop แล้วเลือก tool CLI ตามงานที่ต้องทำ

เครื่องมือ	เหมาะที่สุดสำหรับ	การติดตั้ง	โอเพนซอร์ส?	ข้อสังเกตที่เหมาะกับเอเจนต์
Claude Code	การโค้ดหลายขั้นตอน, การวางแผน	`npm i -g @anthropic-ai/claude-code`	ไม่	`-p` + `--output-format json`, มีค่าใช้จ่ายใน output
Codex CLI	การเปลี่ยนแปลงโค้ด CI ที่กำหนด schema	`npm i -g @openai/codex`	ใช่	`codex exec --json`, `--output-schema`
Gemini CLI	Google stack, งานเน้นการอ่าน	`npm i -g @google/gemini-cli`	ใช่	`--non-interactive --output-format json`
Cursor CLI	ทีม Cursor, editor-to-CI parity	`curl cursor.com/install \	bash`	ไม่
gh	งานทุกประเภทบน GitHub	`brew install gh`	ใช่	`--json` fields และ `--jq` ในตัว
ripgrep	ค้นหาโค้ดแบบมีโครงสร้าง	`brew install ripgrep`	ใช่	`--json` typed match events
jq	ปรับรูปแบบ JSON จากเครื่องมืออื่น	`brew install jq`	ใช่	ใช้เชื่อม pipeline และกรองข้อมูล
HTTPie	API call แบบ JSON ที่เขียนสคริปต์ได้	`brew install httpie`	ใช่	JSON-first และควบคุม `--print` ได้
apidog-cli	วงจรชีวิต API เต็มรูปแบบสำหรับเอเจนต์	`npm i -g apidog-cli`	ไม่ (มีเวอร์ชันฟรี)	JSON-native พร้อม `agentHints.nextSteps`

แนวทางที่ใช้งานได้จริงคือ:

เลือก agent runtime หนึ่งตัว เช่น Claude Code, Codex CLI, Gemini CLI หรือ Cursor CLI
ใช้ gh สำหรับ GitHub
ใช้ rg --json เพื่อค้นหา codebase
ใช้ jq เพื่อแปลงข้อมูลระหว่างคำสั่ง
ใช้ HTTPie หรือ curl สำหรับ API call ทั่วไป
ใช้ apidog-cli เมื่อ workflow ต้องจัดการ API project, mock, test และ branch แบบครบวงจร

สรุป

“Agent-fit” ไม่ใช่คำทางการตลาด แต่ตรวจสอบได้จาก 3 คุณสมบัติ:

structured output ที่ parse ได้
non-interactive mode ที่ไม่ค้างรอ input
deterministic exit codes ที่ใช้ตัดสินใจได้

Agent runtimes เช่น Claude Code, Codex CLI, Gemini CLI และ Cursor CLI ทำหน้าที่วางแผนและลงมือทำ ส่วน tool CLIs เช่น gh, ripgrep, jq, HTTPie และ apidog-cli ให้เอเจนต์มีเครื่องมือที่เชื่อถือได้สำหรับแต่ละขั้นตอน

apidog-cli เพิ่มความสามารถจาก CLI ทั่วไปด้วย JSON-native output, exit code ที่ใช้งานใน CI ได้ และ agentHints.nextSteps ที่เอเจนต์อ่านได้โดยตรง หากงานของคุณเกี่ยวข้องกับ API ให้ดาวน์โหลด Apidog และเริ่มจาก คู่มือ Apidog CLI ฉบับสมบูรณ์ ก่อนเชื่อมเข้ากับ CI ของคุณ

DEV Community