---
read_when:
    - คุณต้องการอ่านหรือเขียนค่าปลายทางภายในไฟล์ของพื้นที่ทำงานจากเทอร์มินัล
    - คุณกำลังเขียนสคริปต์เพื่อทำงานกับสถานะของพื้นที่ทำงาน และต้องการรูปแบบการระบุตำแหน่งที่เสถียรและไม่ขึ้นกับชนิด
    - คุณกำลังดีบักพาธ `oc://` (ตรวจสอบไวยากรณ์และดูว่าพาธนั้นถูกแปลงเป็นอะไร)
summary: เอกสารอ้างอิง CLI สำหรับ `openclaw path` (ตรวจสอบและแก้ไขไฟล์ในพื้นที่ทำงานผ่านรูปแบบการระบุตำแหน่ง `oc://`)
title: พาธ
x-i18n:
    generated_at: "2026-07-12T16:03:02Z"
    model: gpt-5.6
    postprocess_version: locale-links-v1
    provider: openai
    source_hash: 7afe5bd1c3a5fca8dd22c7d807e390e751ae7e895c54bf0e10e2734f3889436c
    source_path: cli/path.md
    workflow: 16
---

# `openclaw path`

การเข้าถึงรูปแบบการระบุที่อยู่ `oc://` ผ่านเชลล์: ไวยากรณ์พาธรูปแบบเดียวที่เลือกการทำงานตามชนิด
สำหรับตรวจสอบและแก้ไขไฟล์ในพื้นที่ทำงานที่ระบุที่อยู่ได้ (markdown, jsonc,
jsonl, yaml/yml/lobster) ผู้โฮสต์ระบบด้วยตนเอง ผู้เขียน Plugin และส่วนขยายเอดิเตอร์
ใช้คำสั่งนี้เพื่ออ่าน ค้นหา หรืออัปเดตตำแหน่งเฉพาะ โดยไม่ต้องเขียน
ตัวแยกวิเคราะห์แยกสำหรับไฟล์แต่ละชนิด

`path` มาจาก Plugin เสริม `oc-path` ที่รวมมาให้ เปิดใช้งานก่อน
ใช้ครั้งแรก:

```bash
openclaw plugins enable oc-path
```

คำกริยาของ CLI สอดคล้องกับรูปแบบการระบุที่อยู่:

- `resolve` ใช้กับพาธที่เจาะจงและต้องตรงกันเพียงรายการเดียว
- `find` เป็นคำกริยาสำหรับผลลัพธ์หลายรายการ ใช้กับไวลด์การ์ด ยูเนียน เพรดิเคต และ
  การขยายตามตำแหน่ง
- `set` ยอมรับเฉพาะพาธที่เจาะจงหรือเครื่องหมายแทรกเท่านั้น รูปแบบไวลด์การ์ด
  จะถูกปฏิเสธก่อนเขียน
- `validate` แยกวิเคราะห์พาธโดยไม่เข้าถึงระบบไฟล์
- `emit` นำไฟล์ผ่านการแยกวิเคราะห์และสร้างผลลัพธ์กลับไปกลับมา (การวินิจฉัยความตรงกันระดับไบต์)

## เหตุผลที่ควรใช้

สถานะของ OpenClaw กระจายอยู่ใน markdown ที่มนุษย์แก้ไข ไฟล์กำหนดค่า JSONC
ที่มีความคิดเห็น บันทึก JSONL แบบเพิ่มต่อท้ายเท่านั้น และไฟล์เวิร์กโฟลว์/ข้อกำหนด YAML สคริปต์ ฮุก
และเอเจนต์มักต้องการค่าเล็ก ๆ เพียงค่าหนึ่งจากไฟล์เหล่านั้น เช่น คีย์ frontmatter
การตั้งค่า Plugin ฟิลด์ของระเบียนบันทึก ขั้นตอน YAML หรือรายการหัวข้อย่อยใต้
ส่วนที่มีชื่อ

`openclaw path` มอบที่อยู่ที่เสถียรให้แก่ผู้เรียกเหล่านั้น แทนการใช้
grep นิพจน์ทั่วไป หรือตัวแยกวิเคราะห์เฉพาะกิจสำหรับไฟล์แต่ละชนิด พาธ `oc://` เดียวกันสามารถนำไปตรวจสอบความถูกต้อง
หาค่า ค้นหา ทดลองทำงานโดยไม่เขียนจริง และเขียนจากเทอร์มินัลได้ ทำให้ระบบอัตโนมัติแบบเฉพาะจุด
ตรวจทานและทำซ้ำได้ง่าย โดยยังคงส่วนที่เหลือของไฟล์ไว้ ดังนั้น
การเขียนค่าปลายทางหนึ่งค่าจะไม่รบกวนความคิดเห็น อักขระจบบรรทัด หรือการจัดรูปแบบ
บริเวณใกล้เคียง

ใช้เมื่อสิ่งที่ต้องการมีที่อยู่เชิงตรรกะ แต่โครงสร้างไฟล์
แตกต่างกัน:

- ฮุกอ่านการตั้งค่าหนึ่งค่าจาก JSONC ที่มีความคิดเห็น โดยไม่ทำความคิดเห็นหายเมื่อ
  เขียนค่ากลับ
- สคริปต์บำรุงรักษาค้นหาฟิลด์เหตุการณ์ที่ตรงกันทั้งหมดในบันทึก JSONL
  โดยไม่โหลดบันทึกทั้งหมดเข้าสู่ตัวแยกวิเคราะห์ที่เขียนขึ้นเอง
- เอดิเตอร์กระโดดไปยังส่วนหรือรายการหัวข้อย่อยใน markdown ตาม slug แล้วแสดงผล
  บรรทัดที่หาได้อย่างแม่นยำ
- เอเจนต์ทดลองแก้ไขพื้นที่ทำงานเพียงเล็กน้อยโดยไม่เขียนจริงก่อนนำไปใช้ พร้อมแสดง
  ไบต์ที่เปลี่ยนแปลงในการตรวจทาน

ไม่ควรใช้ `openclaw path` สำหรับการแก้ไขทั้งไฟล์ทั่วไป การย้ายข้อมูลการกำหนดค่าแบบซับซ้อน หรือ
การเขียนเฉพาะหน่วยความจำ งานเหล่านั้นควรใช้คำสั่งหรือ Plugin ของเจ้าของ `path`
มีไว้สำหรับการดำเนินการกับไฟล์ขนาดเล็กที่ระบุที่อยู่ได้ ซึ่งคำสั่งเทอร์มินัลที่ทำซ้ำได้
เหมาะกว่าการสร้างตัวแยกวิเคราะห์เฉพาะขึ้นมาอีกตัว

## วิธีใช้

อ่านค่าหนึ่งค่าจากไฟล์กำหนดค่าที่มนุษย์แก้ไข:

```bash
openclaw path resolve 'oc://config.jsonc/plugins/github/enabled'
```

ดูตัวอย่างการเขียนโดยไม่แตะต้องดิสก์:

```bash
openclaw path set 'oc://config.jsonc/plugins/github/enabled' 'true' --dry-run
```

ค้นหาระเบียนที่ตรงกันในบันทึก JSONL แบบเพิ่มต่อท้ายเท่านั้น:

```bash
openclaw path find 'oc://session.jsonl/[event=tool_call]/name'
```

ระบุที่อยู่ของคำสั่งใน markdown ตามส่วนและรายการแทนการใช้หมายเลข
บรรทัด:

```bash
openclaw path resolve 'oc://AGENTS.md/runtime-safety/openclaw-gateway'
```

ตรวจสอบความถูกต้องของพาธใน CI หรือสคริปต์ตรวจสอบเบื้องต้น ก่อนที่สคริปต์จะอ่านหรือ
เขียน:

```bash
openclaw path validate 'oc://AGENTS.md/tools/$last/risk'
```

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

## วิธีการทำงาน

1. แยกวิเคราะห์ที่อยู่ `oc://` ออกเป็นช่อง: ไฟล์ ส่วน รายการ ฟิลด์ และ
   คิวรีเซสชันที่ไม่บังคับ
2. เลือกอะแดปเตอร์ชนิดไฟล์จากนามสกุลของเป้าหมาย (`.md`, `.jsonc`,
   `.json`, `.jsonl`, `.ndjson`, `.yaml`, `.yml`, `.lobster`)
3. หาค่าของช่องตามโครงสร้างของไฟล์ชนิดนั้น: หัวข้อ/รายการของ markdown
   คีย์ออบเจ็กต์/ดัชนีอาร์เรย์ของ JSONC ระเบียนแต่ละบรรทัดของ JSONL หรือ
   โหนดแมป/ลำดับของ YAML
4. สำหรับ `set` จะสร้างไบต์ที่แก้ไขแล้วผ่านอะแดปเตอร์เดียวกัน เพื่อให้ส่วนที่ไม่ได้แก้ไข
   ของไฟล์คงความคิดเห็น อักขระจบบรรทัด และการจัดรูปแบบบริเวณใกล้เคียงไว้ในกรณีที่
   ชนิดไฟล์รองรับ

`resolve` และ `set` ต้องการเป้าหมายที่เจาะจงหนึ่งรายการ `find` เป็นคำกริยาสำหรับ
การสำรวจ โดยจะขยายไวลด์การ์ด ยูเนียน เพรดิเคต และลำดับที่ให้เป็นผลลัพธ์ที่เจาะจง
ซึ่งคุณสามารถตรวจสอบก่อนเลือกหนึ่งรายการเพื่อเขียน

## คำสั่งย่อย

| คำสั่งย่อย              | วัตถุประสงค์                                                                     |
| ----------------------- | --------------------------------------------------------------------------- |
| `resolve <oc-path>`     | แสดงผลลัพธ์ที่เจาะจง ณ พาธนั้น (หรือ "ไม่พบ")                      |
| `find <pattern>`        | แจกแจงผลลัพธ์สำหรับพาธแบบไวลด์การ์ด / ยูเนียน / เพรดิเคต                  |
| `set <oc-path> <value>` | เขียนค่าปลายทางหรือเป้าหมายการแทรก ณ พาธที่เจาะจง รองรับ `--dry-run`  |
| `validate <oc-path>`    | แยกวิเคราะห์เท่านั้น แสดงรายละเอียดโครงสร้าง (ไฟล์ / ส่วน / รายการ / ฟิลด์) |
| `emit <file>`           | นำไฟล์ผ่านการแยกวิเคราะห์และสร้างผลลัพธ์กลับไปกลับมา (การวินิจฉัยความตรงกันระดับไบต์)          |

## แฟล็กส่วนกลาง

| แฟล็ก            | ใช้กับ                       | วัตถุประสงค์                                                                  |
| --------------- | -------------------------------- | ------------------------------------------------------------------------ |
| `--cwd <dir>`   | `resolve`, `find`, `set`, `emit` | หาพาธของช่องไฟล์โดยอิงกับไดเรกทอรีนี้ (ค่าเริ่มต้น: `process.cwd()`) |
| `--file <path>` | `resolve`, `find`, `set`, `emit` | แทนที่พาธที่หาได้จากช่องไฟล์ (การเข้าถึงแบบสัมบูรณ์)                |
| `--json`        | ทั้งหมด                              | บังคับผลลัพธ์ JSON (ค่าเริ่มต้นเมื่อ stdout ไม่ใช่ TTY)                    |
| `--human`       | ทั้งหมด                              | บังคับผลลัพธ์ที่มนุษย์อ่านได้ (ค่าเริ่มต้นเมื่อ stdout เป็น TTY)                       |
| `--value-json`  | `set`                            | แยกวิเคราะห์ `<value>` เป็น JSON สำหรับแทนที่ค่าปลายทาง JSON/JSONC/JSONL           |
| `--dry-run`     | `set`                            | แสดงไบต์ที่จะเขียนโดยไม่เขียนจริง                   |
| `--diff`        | `set` (ต้องใช้ `--dry-run`)     | แสดง unified diff แทนไบต์ทั้งหมด                          |

`validate` รับเฉพาะ `--json` / `--human` และไม่เข้าถึงระบบไฟล์ ดังนั้น
จึงใช้ `--cwd` และ `--file` ไม่ได้

## ไวยากรณ์ `oc://`

```text
oc://FILE/SECTION/ITEM/FIELD?session=SCOPE
```

กฎของช่อง: `field` ต้องมี `item` และ `item` ต้องมี `section` สำหรับ
ทั้งสี่ช่อง:

- **เซกเมนต์ที่ใส่เครื่องหมายคำพูด** — `"a/b.c"` จะคงอยู่แม้มีตัวคั่น `/` และ `.` เนื้อหาเป็น
  ค่าไบต์ตามตัวอักษร ไม่อนุญาตให้มี `"` และ `\` ภายในเครื่องหมายคำพูด ช่องไฟล์
  ก็รองรับเครื่องหมายคำพูดเช่นกัน: `oc://"skills/email-drafter"/Tools/$last` ถือว่า
  `skills/email-drafter` เป็นพาธไฟล์เดียว
- **เพรดิเคต** — `[k=v]`, `[k!=v]`, `[k<v]`, `[k<=v]`, `[k>v]`, `[k>=v]`
  ตัวดำเนินการเชิงตัวเลขกำหนดให้ทั้งสองฝั่งต้องแปลงเป็นจำนวนจำกัดได้
- **ยูเนียน** — `{a,b,c}` ตรงกับทางเลือกใดก็ได้
- **ไวลด์การ์ด** — `*` (เซกเมนต์ย่อยเดียว) และ `**` (ศูนย์รายการขึ้นไป
  แบบเรียกซ้ำ) `find` ยอมรับรูปแบบเหล่านี้ ส่วน `resolve` และ `set` ปฏิเสธเพราะ
  มีความกำกวม
- **ตามตำแหน่ง** — `$first` / `$last` หาค่าเป็นดัชนีแรก / สุดท้าย หรือ
  คีย์ที่ประกาศไว้
- **ลำดับที่** — `#N` สำหรับผลลัพธ์ลำดับที่ N ตามลำดับในเอกสาร
- **เครื่องหมายแทรก** — `+`, `+key`, `+nnn` สำหรับการแทรกตามคีย์ / ดัชนี
  (ใช้กับ `set`)
- **ขอบเขตเซสชัน** — `?session=cron-daily` เป็นต้น เป็นอิสระจากการซ้อนของช่อง
  ค่าเซสชันเป็นค่าดิบและไม่มีการถอดรหัสเปอร์เซ็นต์ ต้องไม่มีอักขระควบคุม
  หรือตัวคั่นคิวรีที่สงวนไว้ (`?`, `&`, `%`)

อักขระสงวน (`?`, `&`, `%`) ที่อยู่นอกเซกเมนต์แบบใส่เครื่องหมายคำพูด เพรดิเคต หรือยูเนียน
จะถูกปฏิเสธ อักขระควบคุม (U+0000-U+001F, U+007F) จะถูก
ปฏิเสธทุกตำแหน่ง รวมถึงค่าในคิวรี `session`

รับประกันว่า `formatOcPath(parseOcPath(path)) === path` สำหรับพาธมาตรฐาน
พารามิเตอร์คิวรีที่ไม่เป็นมาตรฐานจะถูกละเว้น ยกเว้นค่า `session=` แรกที่ไม่ว่าง

ขีดจำกัดตายตัว: พาธยาวได้สูงสุด 4096 ไบต์ มีได้ไม่เกิน 4 ช่อง (ไฟล์/ส่วน/รายการ/
ฟิลด์) มีเซกเมนต์ย่อยที่คั่นด้วยจุดได้ไม่เกิน 64 รายการต่อช่อง และมีระดับการเดินโครงสร้างซ้อนกัน
ได้ไม่เกิน 256 ระดับสำหรับพาธ JSON แบบลึก นอกจากนี้ อินพุตไฟล์ JSONC/JSON ใด ๆ
ที่มีขนาดเกิน 16 MiB จะถูกปฏิเสธพร้อมข้อความวินิจฉัยการแยกวิเคราะห์แทนการแยกวิเคราะห์
สำหรับคำกริยาใดก็ตามที่โหลดไฟล์นั้น

## การระบุที่อยู่ตามชนิดไฟล์

| ชนิด          | นามสกุลไฟล์             | รูปแบบการระบุที่อยู่                                                                                    |
| ------------- | --------------------------- | --------------------------------------------------------------------------------------------------- |
| Markdown      | `.md`                       | ส่วน H2 ตาม slug รายการหัวข้อย่อยตาม slug หรือ `#N` และ frontmatter ผ่าน `[frontmatter]`                 |
| JSONC/JSON    | `.jsonc`, `.json`           | คีย์ออบเจ็กต์และดัชนีอาร์เรย์ จุดจะแบ่งเซกเมนต์ย่อยที่ซ้อนกัน เว้นแต่ใส่เครื่องหมายคำพูด                        |
| JSONL         | `.jsonl`, `.ndjson`         | ที่อยู่บรรทัดระดับบนสุด (`L1`, `L2`, `$first`, `$last`) จากนั้นเดินโครงสร้างภายในบรรทัดแบบ JSONC |
| YAML/.lobster | `.yaml`, `.yml`, `.lobster` | คีย์แมปและดัชนีลำดับ ความคิดเห็นและรูปแบบโฟลว์จัดการโดย API เอกสาร YAML        |

`resolve` ส่งคืนผลลัพธ์ที่มีโครงสร้าง: `root`, `node`, `leaf` หรือ
`insertion-point` พร้อมหมายเลขบรรทัดที่เริ่มนับจาก 1 ค่าปลายทางจะแสดงเป็น
ข้อความพร้อม `leafType` เพื่อให้ผู้เขียน Plugin แสดงตัวอย่างได้โดยไม่ต้อง
พึ่งพารูปร่าง AST เฉพาะของแต่ละชนิด

## สัญญาการเปลี่ยนแปลง

`set` เขียนเป้าหมายที่เจาะจงหนึ่งรายการ:

- ค่า frontmatter ของ Markdown และฟิลด์รายการ `- key: value` เป็นค่าปลายทาง
  ชนิดสตริง การแทรกใน Markdown จะเพิ่มส่วน คีย์ frontmatter หรือรายการในส่วน
  ต่อท้าย และสร้างรูปแบบ markdown มาตรฐานสำหรับไฟล์ที่เปลี่ยนแปลง ไม่สามารถเขียนเนื้อหา
  ของส่วนทั้งก้อนผ่าน `set` ได้
- การเขียนค่าปลายทาง JSONC จะแปลงค่าสตริงให้เป็นชนิดเดียวกับค่าปลายทางเดิม
  (`string`, `number` ที่เป็นจำนวนจำกัด, `true`/`false` หรือ `null`) ใช้ `--value-json`
  เมื่อการแทนที่ค่าปลายทาง JSONC/JSON/JSONL ควรแยกวิเคราะห์ `<value>` เป็น JSON และ
  อาจเปลี่ยนโครงสร้าง เช่น แทนที่รูปแบบย่อของการอ้างอิงข้อมูลลับชนิดสตริงด้วย
  ออบเจ็กต์ การแทรกออบเจ็กต์และอาร์เรย์ JSONC จะแยกวิเคราะห์ `<value>` เป็น JSON และใช้
  พาธการแก้ไขของ `jsonc-parser` สำหรับการเขียนค่าปลายทางทั่วไป โดยรักษาความคิดเห็น
  และการจัดรูปแบบบริเวณใกล้เคียงไว้
- การเขียนค่าปลายทาง JSONL จะแปลงชนิดเหมือน JSONC ภายในบรรทัด การแทนที่ทั้งบรรทัด
  และการเพิ่มต่อท้ายจะแยกวิเคราะห์ `<value>` เป็น JSON ผลลัพธ์ JSONL จะรักษารูปแบบ
  อักขระจบบรรทัด LF/CRLF ที่ใช้เป็นหลักของไฟล์ (พิจารณาจากเสียงข้างมากของอักขระขึ้นบรรทัดใหม่
  ทั่วทั้งไฟล์ ดังนั้นไฟล์ที่ส่วนใหญ่เป็น CRLF จะยังคงเป็น CRLF แม้มี LF แทรกอยู่บางส่วน)
- การเขียนค่าปลายทาง YAML จะแปลงเป็นชนิดสเกลาร์เดียวกับค่าเดิม (`string`, `number`
  ที่เป็นจำนวนจำกัด, `true`/`false` หรือ `null`) การแทรก YAML ใช้ API เอกสารของแพ็กเกจ
  `yaml` ที่รวมมาให้สำหรับอัปเดตแมป/ลำดับ เอกสาร YAML ที่ผิดรูปแบบและมีข้อผิดพลาด
  จากตัวแยกวิเคราะห์จะถูกปฏิเสธก่อนเปลี่ยนแปลง พร้อม `parse-error`

ใช้ `--dry-run` ก่อนการเขียนที่ผู้ใช้มองเห็น เมื่อความแม่นยำของไบต์มีความสำคัญ การแก้ไข JSONC
และ YAML จะแพตช์เอกสารเดิม (ผ่าน `jsonc-parser` หรือ API
เอกสาร `yaml`) ดังนั้นไบต์ที่ไม่ถูกแก้ไขมักคงอยู่ ส่วน markdown จะสร้างไฟล์ใหม่
จากโครงสร้างที่แยกวิเคราะห์ทุกครั้งที่แก้ไข ซึ่งอาจปรับการจัดรูปแบบประกอบ
นอกค่าปลายทางที่เปลี่ยนแปลงให้เป็นมาตรฐาน เพิ่ม `--diff` เมื่อต้องการดูตัวอย่าง
เป็นแพตช์ก่อน/หลังแบบเจาะจง แทนไฟล์ที่แสดงผลทั้งหมด

## ตัวอย่าง

```bash
# ตรวจสอบความถูกต้องของพาธ (ไม่เข้าถึงระบบไฟล์)
openclaw path validate 'oc://AGENTS.md/Tools/$last/risk'

# อ่านค่าปลายทาง
openclaw path resolve 'oc://gateway.jsonc/version'

# ค้นหาด้วยไวลด์การ์ด
openclaw path find 'oc://session.jsonl/*/event' --file ./logs/session.jsonl

# ทดลองเขียนโดยไม่เขียนจริง
openclaw path set 'oc://gateway.jsonc/version' '2.0' --dry-run

# ทดลองเขียนโดยไม่เขียนจริงในรูปแบบ unified diff
openclaw path set 'oc://gateway.jsonc/version' '2.0' --dry-run --diff

# นำการเขียนไปใช้
openclaw path set 'oc://gateway.jsonc/version' '2.0'

# การนำผ่านไปกลับโดยคงความตรงกันระดับไบต์ (การวินิจฉัย)
openclaw path emit ./AGENTS.md
```

ตัวอย่างไวยากรณ์เพิ่มเติม:

```bash
# Quote keys containing / or .
openclaw path resolve 'oc://config.jsonc/agents.defaults.models/"anthropic/claude-opus-4-7"/alias'

# Deep JSON/JSONC paths can use slash segments; they normalize to dotted subsegments
openclaw path set 'oc://openclaw.json/agents/list/0/tools/exec/security' 'allowlist' --dry-run

# Replace a JSONC leaf with a parsed object
openclaw path set 'oc://openclaw.json/gateway/auth/token' '{"source":"file","provider":"secrets","id":"/test"}' --value-json --dry-run

# Predicate search over JSONC children
openclaw path find 'oc://config.jsonc/plugins/[enabled=true]/id'

# Insert into a JSONC array
openclaw path set 'oc://config.jsonc/items/+1' '{"id":"new","enabled":true}' --dry-run

# Insert a JSONC object key
openclaw path set 'oc://config.jsonc/plugins/+github' '{"enabled":true}' --dry-run

# Append a JSONL event
openclaw path set 'oc://session.jsonl/+' '{"event":"checkpoint","ok":true}' --file ./logs/session.jsonl

# Resolve the last JSONL value line
openclaw path resolve 'oc://session.jsonl/$last/event' --file ./logs/session.jsonl

# Resolve a YAML workflow step
openclaw path resolve 'oc://workflow.yaml/steps/0/id'

# Update a YAML scalar
openclaw path set 'oc://workflow.yaml/steps/$last/id' 'classify-renamed' --dry-run

# Address markdown frontmatter
openclaw path resolve 'oc://AGENTS.md/[frontmatter]/name'

# Insert markdown frontmatter
openclaw path set 'oc://AGENTS.md/[frontmatter]/+description' 'Agent instructions' --dry-run

# Find markdown item fields
openclaw path find 'oc://SKILL.md/Tools/*/send_email'

# Validate a session-scoped path
openclaw path validate 'oc://AGENTS.md/Tools/$last/risk?session=cron-daily'
```

## สูตรตามชนิดไฟล์

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

### Markdown

```text
<!-- frontmatter.md -->
---
name: drafter
description: email drafting agent
tier: core
---
## Tools
- gh: GitHub CLI
- curl: HTTP client
- send_email: enabled
```

```bash
$ openclaw path resolve 'oc://x.md/[frontmatter]/tier' --file frontmatter.md --human
leaf @ L4: "core" (string)

$ openclaw path resolve 'oc://x.md/tools/gh/gh' --file frontmatter.md --human
leaf @ L9: "GitHub CLI" (string)

$ openclaw path find 'oc://x.md/tools/*' --file frontmatter.md --human
3 matches for oc://x.md/tools/*:
  oc://x.md/tools/gh           →  node @ L9 [md-item]
  oc://x.md/tools/curl         →  node @ L10 [md-item]
  oc://x.md/tools/send-email   →  node @ L11 [md-item]
```

เพรดิเคต `[frontmatter]` ใช้ระบุบล็อก YAML frontmatter ส่วน `tools`
จะตรงกับหัวข้อ `## Tools` ผ่าน slug และใบรายการจะคงรูปแบบ slug ไว้
แม้ว่าต้นฉบับจะใช้ขีดล่าง (`send_email` จะกลายเป็น `send-email`)

### JSONC

```text
// config.jsonc
{
  "plugins": {
    "github": {"enabled": true, "role": "vcs"},
    "slack":  {"enabled": false, "role": "chat"}
  }
}
```

```bash
$ openclaw path resolve 'oc://config.jsonc/plugins/github/enabled' --file config.jsonc --human
leaf @ L4: "true" (boolean)

$ openclaw path set 'oc://config.jsonc/plugins/slack/enabled' 'true' --file config.jsonc --dry-run
--dry-run: would write 142 bytes to /…/config.jsonc
{
  "plugins": {
    "github": {"enabled": true, "role": "vcs"},
    "slack":  {"enabled": true, "role": "chat"}
  }
}
```

การแก้ไข JSONC ดำเนินการผ่าน `jsonc-parser` ดังนั้นความคิดเห็นและช่องว่างจะยังคงอยู่หลังการ
`set` ควรรันด้วย `--dry-run` ก่อนเพื่อตรวจสอบไบต์ก่อนยืนยันการเปลี่ยนแปลง
ไฟล์ `.json` ใช้อะแดปเตอร์และเส้นทางการแก้ไขเดียวกับ `.jsonc`

### JSONL

```text
{"event":"start","userId":"u1","ts":1}
{"event":"action","userId":"u1","ts":2}
{"event":"end","userId":"u1","ts":3}
```

```bash
$ openclaw path find 'oc://session.jsonl/[event=action]/userId' --file session.jsonl --human
1 match for oc://session.jsonl/[event=action]/userId:
  oc://session.jsonl/L2/userId  →  leaf @ L2: "u1" (string)

$ openclaw path resolve 'oc://session.jsonl/L2/ts' --file session.jsonl --human
leaf @ L2: "2" (number)
```

แต่ละบรรทัดคือหนึ่งระเบียน หากไม่ทราบหมายเลขบรรทัด ให้ระบุที่อยู่ด้วยเพรดิเคต
(`[event=action]`) หรือใช้เซกเมนต์มาตรฐาน `LN` เมื่อทราบหมายเลขบรรทัด
ไฟล์ `.ndjson` ใช้อะแดปเตอร์เดียวกับ `.jsonl`

### YAML

```text
# workflow.yaml
name: inbox-triage
steps:
  - id: fetch
    command: gmail.search
  - id: classify
    command: openclaw.invoke
```

```bash
$ openclaw path resolve 'oc://workflow.yaml/steps/0/id' --file workflow.yaml --human
leaf @ L3: "fetch" (string)

$ openclaw path set 'oc://workflow.yaml/steps/$last/id' 'classify-renamed' --file workflow.yaml --dry-run
--dry-run: would write 99 bytes to /…/workflow.yaml
name: inbox-triage
steps:
  - id: fetch
    command: gmail.search
  - id: classify-renamed
    command: openclaw.invoke
```

YAML ใช้ API `Document` ของแพ็กเกจ `yaml` แทนพาร์เซอร์ที่เขียนขึ้นเอง
ดังนั้นการแปลงไปกลับระหว่างการแยกวิเคราะห์และการส่งออกตามปกติจะรักษาความคิดเห็นและรูปแบบการเขียน
ไว้ ขณะที่พาธที่ได้รับการแก้ไขจะใช้โมเดลคีย์ของแมป / ดัชนีลำดับแบบเดียวกับ
JSONC อะแดปเตอร์เดียวกันนี้รองรับไฟล์ `.yaml`, `.yml` และ `.lobster`

## ข้อมูลอ้างอิงคำสั่งย่อย

### `resolve <oc-path>`

อ่านใบหรือโหนดหนึ่งรายการ ไม่รองรับไวลด์การ์ด — ให้ใช้ `find` สำหรับกรณีดังกล่าว
ออกด้วยรหัส `0` เมื่อพบรายการตรงกัน, `1` เมื่อไม่พบโดยไม่มีข้อผิดพลาด และ `2` เมื่อเกิดข้อผิดพลาดในการแยกวิเคราะห์หรือ
รูปแบบถูกปฏิเสธ

```bash
openclaw path resolve 'oc://AGENTS.md/tools/gh/risk' --human
openclaw path resolve 'oc://gateway.jsonc/server/port' --json
```

### `find <pattern>`

แจกแจงรายการที่ตรงกันทั้งหมดสำหรับรูปแบบไวลด์การ์ด / เพรดิเคต / ยูเนียน ออกด้วยรหัส `0`
เมื่อพบอย่างน้อยหนึ่งรายการ และ `1` เมื่อไม่พบเลย ไวลด์การ์ดในช่องไฟล์จะถูกปฏิเสธด้วย
`OC_PATH_FILE_WILDCARD_UNSUPPORTED` — ให้ระบุไฟล์ที่แน่นอน (การจับคู่แบบ glob หลายไฟล์
เป็นความสามารถที่จะเพิ่มในภายหลัง)

```bash
openclaw path find 'oc://AGENTS.md/tools/**/risk'
openclaw path find 'oc://session.jsonl/[event=action]/userId'
openclaw path find 'oc://config.jsonc/plugins/{github,slack}/enabled'
```

### `set <oc-path> <value>`

เขียนค่าลงในใบ ใช้ร่วมกับ `--dry-run` เพื่อดูตัวอย่างไบต์ที่จะถูก
เขียนโดยไม่แก้ไขไฟล์ เพิ่ม `--diff` เพื่อดูตัวอย่าง diff แบบรวม
ออกด้วยรหัส `0` เมื่อเขียนสำเร็จ, `1` หากชั้นข้อมูลปฏิเสธ (ตัวอย่างเช่น
ตรวจพบตัวป้องกันเซนทิเนล) และ `2` เมื่อเกิดข้อผิดพลาดในการแยกวิเคราะห์

```bash
openclaw path set 'oc://gateway.jsonc/version' '2.0' --dry-run
openclaw path set 'oc://gateway.jsonc/version' '2.0' --dry-run --diff
openclaw path set 'oc://gateway.jsonc/version' '2.0'
openclaw path set 'oc://AGENTS.md/Tools/+gh/risk' 'low'
```

เครื่องหมายแทรก `+key` จะสร้างโหนดย่อยตามชื่อหากยังไม่มีอยู่
ส่วน `+nnn` และ `+` เดี่ยวใช้สำหรับการแทรกตามดัชนีและการต่อท้าย
ตามลำดับ

### `validate <oc-path>`

ตรวจสอบเฉพาะการแยกวิเคราะห์ โดยไม่เข้าถึงระบบไฟล์ มีประโยชน์เมื่อต้องการยืนยันว่า
พาธเทมเพลตมีรูปแบบถูกต้องก่อนแทนค่าตัวแปร หรือเมื่อต้องการ
รายละเอียดโครงสร้างสำหรับการดีบัก:

```bash
$ openclaw path validate 'oc://AGENTS.md/tools/gh' --human
valid: oc://AGENTS.md/tools/gh
  file:    AGENTS.md
  section: tools
  item:    gh
```

ออกด้วยรหัส `0` เมื่อถูกต้อง, `1` เมื่อไม่ถูกต้อง (พร้อม `code` และ
`message` ที่มีโครงสร้าง) และ `2` เมื่อเกิดข้อผิดพลาดของอาร์กิวเมนต์

### `emit <file>`

ส่งไฟล์ผ่านพาร์เซอร์และตัวส่งออกตามชนิดไฟล์แบบไปกลับ ผลลัพธ์ควร
ตรงกับอินพุตทุกไบต์หากไฟล์สมบูรณ์ ความแตกต่างบ่งชี้ถึง
ข้อบกพร่องของพาร์เซอร์หรือการตรวจพบเซนทิเนล มีประโยชน์สำหรับดีบักพฤติกรรมของชั้นข้อมูลกับ
อินพุตที่ใช้งานจริง

```bash
openclaw path emit ./AGENTS.md
openclaw path emit ./gateway.jsonc --json
```

## รหัสออก

| รหัส | ความหมาย                                                                    |
| ---- | -------------------------------------------------------------------------- |
| `0`  | สำเร็จ (`resolve` / `find`: พบอย่างน้อยหนึ่งรายการ `set`: เขียนสำเร็จ) |
| `1`  | ไม่พบรายการ หรือ `set` ถูกชั้นข้อมูลปฏิเสธ (ไม่มีข้อผิดพลาดระดับระบบ)      |
| `2`  | ข้อผิดพลาดของอาร์กิวเมนต์หรือการแยกวิเคราะห์                                                   |

## โหมดเอาต์พุต

`openclaw path` ตรวจจับ TTY ได้ โดยแสดงเอาต์พุตที่มนุษย์อ่านได้บนเทอร์มินัล และใช้ JSON เมื่อ
stdout ถูกส่งผ่านไปป์หรือเปลี่ยนเส้นทาง `--json` และ `--human` จะมีผลเหนือ
การตรวจจับอัตโนมัติ

## หมายเหตุ

- `set` เขียนไบต์ผ่านเส้นทางการส่งออกของชั้นข้อมูล ซึ่งใช้
  ตัวป้องกันเซนทิเนลสำหรับการปกปิดข้อมูลโดยอัตโนมัติ ใบที่มีค่า
  `__OPENCLAW_REDACTED__` (ตรงตัวหรือเป็นส่วนหนึ่งของสตริง) จะถูกปฏิเสธในขณะเขียน
- การแยกวิเคราะห์ JSONC และการแก้ไขใบใช้ดีเพนเดนซี `jsonc-parser`
  ที่อยู่ภายใน Plugin ดังนั้นความคิดเห็นและการจัดรูปแบบจะยังคงอยู่ในการเขียนใบตามปกติ
  แทนที่จะผ่านเส้นทางพาร์เซอร์/การเรนเดอร์ใหม่ที่เขียนขึ้นเอง
- `path` ไม่รับรู้การติดตามหรือการกู้คืนการกำหนดค่าที่ทราบว่าดีล่าสุด (LKG)
  วงจรชีวิตดังกล่าวมีเจ้าของอยู่ในส่วนอื่น หากไฟล์ที่คุณแก้ไขผ่าน `path`
  ถูกติดตามด้วย LKG ด้วย การอ่านการกำหนดค่าครั้งถัดไปจะเป็นตัวตัดสินว่าจะเลื่อนสถานะหรือ
  กู้คืนไฟล์นั้น ให้ถือว่าการแก้ไขผ่าน `path` เหมือนกับการเขียนโดยตรงแบบอื่น ๆ ไปยัง
  ไฟล์นั้น

## ที่เกี่ยวข้อง

- [ข้อมูลอ้างอิง CLI](/th/cli)
