Przejdź do treści
Biblioteka skilli
Dokumenty i biuro · Integracja z narzędziem

craft

/craft

Czyta i zapisuje dokumenty Craft przez Craft Connect API: tworzenie, odczyt, aktualizacja i wyszukiwanie, zadania, notatki dzienne, foldery, kolekcje i formatowanie bogatej treści.

Licencja
MIT
Ostatnia zmiana repozytorium
20.07.2026

Ocena i bezpieczeństwo

90/ 100Klasa: dobry
Format20 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść30 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
3
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
7
Przestarzałość

Brak sygnałów. Repozytorium zmienione 20.07.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Czyta i zapisuje dokumenty Craft przez Craft Connect API: tworzenie, odczyt, aktualizacja i wyszukiwanie, zadania, notatki dzienne, foldery, kolekcje i formatowanie bogatej treści.

Oryginalny opis (EN)

Read and write Craft documents via the Craft Connect API. Use when the user asks to create, read, update, or search Craft documents, manage tasks, write daily notes, organize folders, work with collections (structured databases), or format rich content. Covers all block types including toggles, callouts, tables, code, highlights, math formulas, images, cards, and styled text. NOT for general note-taking to local files or unrelated document editors. Requires: CRAFT_API_URL (Craft Connect API base URL with embedded link token, stored in TOOLS.md). Uses curl for all HTTP requests.

Jak działa

  1. Requirements
  2. Setup
  3. API Reference
  4. Block Types & Formatting
  5. Choosing Insert Method
  6. Gotchas & Lessons Learned
Sekcje z nagłówków SKILL.md, w oryginale · 553 linii, 2 006 słów
Podgląd SKILL.md
---
name: craft
description: >
  Read and write Craft documents via the Craft Connect API. Use when the user
  asks to create, read, update, or search Craft documents, manage tasks, write
  daily notes, organize folders, work with collections (structured databases),
  or format rich content. Covers all block types including toggles, callouts,
  tables, code, highlights, math formulas, images, cards, and styled text.
  NOT for general note-taking to local files or unrelated document editors.
  Requires: CRAFT_API_URL (Craft Connect API base URL with embedded link token,
  stored in TOOLS.md). Uses curl for all HTTP requests.
---

# Craft Document Management

Operate on a Craft space via the Craft Connect REST API. Full CRUD on documents,
blocks, folders, tasks, collections, and comments.

## Requirements

- **curl** — used for all API requests
- **CRAFT_API_URL** — your Craft Connect API base URL (contains embedded link token for authentication)

## Setup

1. Create a Craft Connect link in your Craft space (Settings → Connect → Create Link)
2. Copy the API base URL and store it in TOOLS.md under a Craft section:

```
CRAFT_API_URL=https://connect.craft.do/links/<LINK_ID>/api/v1
```

3. Read TOOLS.md before making any calls to retrieve the URL.

All calls use `curl` with `-H "Content-Type: application/json"` for writes and
`-H "Accept: application/json"` for reads.

**Important:** URL-encode non-ASCII characters (e.g. Chinese) in query params.

---

## API Reference

### Connection Info

```bash
curl -s "$CRAFT_API_URL/connection"
```

Returns space ID, timezone, current time, and deep-link URL templates.

### Discovery

```bash
# List all folders and locations
curl -s "$CRAFT_API_URL/folders"

# List documents in a location (unsorted | trash | templates | daily_notes)
curl -s "$CRAFT_API_URL/documents?location=unsorted"

# List documents in a folder
curl -s "$CRAFT_API_URL/documents?folderId=<FOLDER_ID>"

# With metadata (creation/modification dates, deep links)
curl -s "$CRAFT_API_URL/documents?location=unsorted&fetchMetadata=true"

# Date filters (ISO YYYY-MM-DD or: today, yesterday, tomorrow)
curl -s "$CRAFT_API_URL/documents?createdDateGte=2025-01-01&lastModifiedDateLte=today"
```

### Search

```bash
# Search across ALL documents (URL-encode non-ASCII!)
curl -s "$CRAFT_API_URL/documents/search?include=<TERM>&fetchMetadata=true"

# Search within a specific document (with context blocks)
curl -s "$CRAFT_API_URL/blocks/search?blockId=<DOC_ID>&pattern=<REGEX>&beforeBlockCount=2&afterBlockCount=2"

# Filter search by folder or location
curl -s "$CRAFT_API_URL/documents/search?include=<TERM>&folderIds=<FOLDER_ID>"
curl -s "$CRAFT_API_URL/documents/search?include=<TERM>&location=daily_notes"
```

### Documents

```bash
# Create document (defaults to unsorted)
curl -s -X POST "$CRAFT_API_URL/documents" \
  -H "Content-Type: application/json" \
  -d '{"documents": [{"title": "My Document"}]}'

# Create in a specific folder
curl -s -X POST "$CRAFT_API_URL/documents" \
  -H "Content-Type: application/json" \
  -d '{"documents": [{"title": "Doc"}], "destination": {"folderId": "<ID>"}}'

# Create as template
curl -s -X POST "$CRAFT_API_URL/documents" \
  -H "Content-Type: application/json" \
  -d '{"documents": [{"title": "Template"}], "destination": {"destination": "templates"}}'

# Delete (soft-delete to trash, recoverable)
curl -s -X DELETE "$CRAFT_API_URL/documents" \
  -H "Content-Type: application/json" \
  -d '{"documentIds": ["<DOC_ID>"]}'

# Move between locations
curl -s -X PUT "$CRAFT_API_URL/documents/move" \
  -H "Content-Type: application/json" \
  -d '{"documentIds": ["<ID>"], "destination": {"folderId": "<FOLDER_ID>"}}'

# Restore from trash
curl -s -X PUT "$CRAFT_API_URL/documents/move" \
  -H "Content-Type: application/json" \
  -d '{"documentIds": ["<ID>"], "destination": {"destination": "unsorted"}}'
```

### Reading Content

```bash
# Get document content (JSON)
curl -s "$CRAFT_API_URL/blocks?id=<DOC_ID>" -H "Accept: application/json"

# Get daily note
curl -s "$CRAFT_API_URL/blocks?date=today" -H "Accept: application/json"

# Control depth (0=block only, 1=direct children, -1=all)
curl -s "$CRAFT_API_URL/blocks?id=<ID>&maxDepth=1"

# With metadata (comments, authors, timestamps)
curl -s "$CRAFT_API_URL/blocks?id=<ID>&fetchMetadata=true"
```

### Writing Content

Two methods: **markdown** (recommended) and **blocks JSON**.

#### Method 1: Markdown (Recommended)

Best for most content. Craft parses markdown and auto-generates correct block
types, indentation levels, and list styles.

```bash
curl -s -X POST "$CRAFT_API_URL/blocks" \
  -H "Content-Type: application/json" \
  -d '{
    "markdown": "## Heading\n\nParagraph\n\n- bullet 1\n- bullet 2",
    "position": {"position": "end", "pageId": "<DOC_ID>"}
  }'
```

#### Method 2: Blocks JSON

Use when you need explicit control over `color`, `font`, `textStyle`, or other
properties not expressible in plain markdown.

```bash
curl -s -X POST "$CRAFT_API_URL/blocks" \
  -H "Content-Type: application/json" \
  -d '{
    "blocks": [
      {"type": "text", "textStyle": "h2", "markdown": "## Title"},
      {"type": "text", "color": "#00A3CB", "markdown": "<callout>💡 Info</callout>"}
    ],
    "position": {"position": "end", "pageId": "<DOC_ID>"}
  }'
```

#### Position Options

| Position | Syntax |
|----------|--------|
| Append to document | `{"position": "end", "pageId": "<DOC_ID>"}` |
| Prepend to document | `{"position": "start", "pageId": "<DOC_ID>"}` |
| After a specific block | `{"position": "after", "siblingId": "<BLOCK_ID>"}` |
| Before a specific block | `{"position": "before", "siblingId": "<BLOCK_ID>"}` |
| Append to daily note | `{"position": "end", "date": "today"}` |

### Updating & Deleting Blocks

```bash
# Update (only provided fields change; others preserved)
curl -s -X PUT "$CRAFT_API_URL/blocks" \
  -H "Content-Type: application/json" \
  -d '{"blocks": [{"id": "<BLOCK_ID>", "markdown": "Updated", "font": "serif"}]}'

# Delete blocks (permanent!)
curl -s -X DELETE "$CRAFT_API_URL/blocks" \
  -H "Content-Type: application/json" \
  -d '{"blockIds": ["<ID1>", "<ID2>"]}'

# Move blocks between documents
curl -s -X PUT "$CRAFT_API_URL/blocks/move" \
  -H "Content-Type: application/json" \
  -d '{"blockIds": ["<ID>"], "position": {"position": "end", "pageId": "<DOC_ID>"}}'
```

### Tasks

```bash
# List tasks (scopes: inbox, active, upcoming, logbook, document)
curl -s "$CRAFT_API_URL/tasks?scope=active"
curl -s "$CRAFT_API_URL/tasks?scope=document&documentId=<DOC_ID>"

# Create task in inbox
curl -s -X POST "$CRAFT_API_URL/tasks" \
  -H "Content-Type: application/json" \
  -d '{"tasks": [{"markdown": "Task text", "taskInfo": {"scheduleDate": "tomorrow"}, "location": {"type": "inbox"}}]}'

# Create task in daily note
curl -s -X POST "$CRAFT_API_URL/tasks" \
  -H "Content-Type: application/json" \
  -d '{"tasks": [{"markdown": "Task", "taskInfo": {"scheduleDate": "2025-01-20", "deadlineDate": "2025-01-22"}, "location": {"type": "dailyNote", "date": "today"}}]}'

# Create task in a document
curl -s -X POST "$CRAFT_API_URL/tasks" \
  -H "Content-Type: application/json" \
  -d '{"tasks": [{"markdown": "Task", "location": {"type": "document", "documentId": "<DOC_ID>"}}]}'

# Complete task
curl -s -X PUT "$CRAFT_API_URL/tasks" \
  -H "Content-Type: application/json" \
  -d '{"tasksToUpdate": [{"id": "<TASK_ID>", "taskInfo": {"state": "done"}}]}'

# Delete task
curl -s -X DELETE "$CRAFT_API_URL/tasks" \
  -H "Content-Type: application/json" \
  -d '{"idsToDelete": ["<TASK_ID>"]}'
```

### Folders

```bash
# Create folder (root level)
curl -s -X POST "$CRAFT_API_URL/folders" \
  -H "Content-Type: application/json" \
  -d '{"folders": [{"name": "New Folder"}]}'

# Create nested folder
curl -s -X POST "$CRAFT_API_URL/folders" \
  -H "Content-Type: application/json" \
  -d '{"folders": [{"name": "Sub", "parentFolderId": "<PARENT_ID>"}]}'

# Delete folder (docs move to parent or Unsorted)
curl -s -X DELETE "$CRAFT_API_URL/folders" \
  -H "Content-Type: application/json" \
  -d '{"folderIds": ["<FOLDER_ID>"]}'

# Move folder
curl -s -X PUT "$CRAFT_API_URL/folders/move" \
  -H "Content-Type: application/json" \
  -d '{"folderIds": ["<ID>"], "destination": "root"}'
# or: "destination": {"parentFolderId": "<ID>"}
```

### Collections (Structured Databases)

Collections are like Notion databases — structured tables with typed columns.

```bash
# List all collections
curl -s "$CRAFT_API_URL/collections"

# Create collection in a document
curl -s -X POST "$CRAFT_API_URL/collections" \
  -H "Content-Type: application/json" \
  -d '{
    "schema": {
      "name": "Tasks",
      "contentPropDetails": {"name": "Title"},
      "properties": [
        {"name": "Status", "type": "singleSelect", "options": [{"name": "Todo"}, {"name": "In Progress"}, {"name": "Done"}]},
        {"name": "Priority", "type": "singleSelect", "options": [{"name": "High"}, {"name": "Medium"}, {"name": "Low"}]},
        {"name": "Due Date", "type": "date"}
      ]
    },
    "position": {"position": "end", "pageId": "<DOC_ID>"}
  }'

# Get schema (use json-schema-items format to learn the property keys!)
curl -s "$CRAFT_API_URL/collections/<COL_ID>/schema?format=json-schema-items"
# ⚠️ IMPORTANT: schema returns auto-generated keys like "", "_2", "_3", "_4"
# You MUST read the schema first to know the correct keys for items

# Get items
curl -s "$CRAFT_API_URL/collections/<COL_ID>/items"

# Add items (use schema keys, NOT "title"!)
# First GET the schema to find the contentProp key (e.g. "_4" for title)
curl -s -X POST "$CRAFT_API_URL/collections/<COL_ID>/items" \
  -H "Content-Type: application/json" \
  -d '{"items": [{"<CONTENT_KEY>": "Item Title", "properties": {"<STATUS_KEY>": "Todo", "<PRIORITY_KEY>": "High"}}]}'

# Update items
curl -s -X PUT "$CRAFT_API_URL/collections/<COL_ID>/items" \
  -H "Content-Type: application/json" \
  -d '{"itemsToUpdate": [{"id": "<ITEM_ID>", "properties": {"<STATUS_KEY>": "Done"}}]}'

# Delete items
curl -s -X DELETE "$CRAFT_API_URL/collections/<COL_ID>/items" \
  -H "Content-Type: application/json" \
  -d '{"idsToDelete": ["<ITEM_ID>"]}'

# Update schema (replaces entirely — include ALL fields you want to keep)
curl -s -X PUT "$CRAFT_API_URL/collections/<COL_ID>/schema" \
  -H "Content-Type: application/json" \
  -d '{"schema": { ... }}'
```

### Comments

```bash
curl -s -X POST "$CRAFT_API_URL/comments" \
  -H "Content-Type: application/json" \
  -d '{"comments": [{"blockId": "<BLOCK_ID>", "content": "Comment text"}]}'
```

### File Upload

```bash
curl -s -X POST "$CRAFT_API_URL/upload?position=end&pageId=<DOC_ID>" \
  -H "Content-Type: application/octet-stream" \
  --data-binary @file.png
```

Position params: `position` (start|end|before|after) + `pageId`/`date`/`siblingId`.

---

## Block Types & Formatting

### Headings

```markdown
# H1 Title          → textStyle: "h1"
## H2 Subtitle      → textStyle: "h2"
### H3 Heading      → textStyle: "h3"
#### H4 Strong      → textStyle: "h4"
```

### Inline Styles

```markdown
**bold**, *italic*, ~strikethrough~, `inline code`
[link text](https://url)
$(a+b)^2$                    ← inline equation
```

### Highlights (9 solid + 5 gradient)

```markdown
<highlight color="COLOR">text</highlight>
```

Solid: `yellow`, `blue`, `red`, `green`, `purple`, `pink`, `mint`, `cyan`, `gray`
Gradient: `gradient-blue`, `gradient-purple`, `gradient-red`, `gradient-yellow`, `gradient-brown`

### Lists

```markdown
- bullet item           → listStyle: "bullet"
1. numbered item        → listStyle: "numbered"
- [ ] todo task         → listStyle: "task", taskInfo.state: "todo"
- [x] completed task    → listStyle: "task", taskInfo.state: "done"
+ toggle (collapsible)  → listStyle: "toggle"
```

### Toggle (Collapsible) Lists — CRITICAL

Children MUST be indented 2 spaces to nest inside a toggle:

```markdown
+ Parent toggle
  - Child 1 (hidden when collapsed)
  - Child 2
  + Nested toggle
    - Deep child
```

**Use markdown mode only.** `indentationLevel` in blocks JSON is silently
ignored on insert.

### Blockquote

```markdown
> Quoted text
```

Produces block with `decorations: ["quote"]`.

### Dividers / Lines

Blocks JSON with `lineStyle`:

```json
{"type": "line", "lineStyle": "extraLight", "markdown": "***"}
{"type": "line", "lineStyle": "light", "markdown": "****"}
{"type": "line", "lineStyle": "regular", "markdown": "*****"}
{"type": "line", "lineStyle": "strong", "markdown": "******"}
```

Markdown mode: `---` produces `extraLight` by default.

### Code Blocks

Markdown mode:

````markdown
```python
def hello():
    print("Hello")
```
````

Blocks JSON (requires `rawCode`!):

```json
{"type": "code", "language": "python", "rawCode": "def hello():\n    print('Hello')", "markdown": "```python\ndef hello():\n    print('Hello')\n```"}
```

### Math Formula (TeX)

```json
{"type": "code", "language": "math_formula", "rawCode": "x = \\frac{-b \\pm \\sqrt{b^2 - 4ac}}{2a}", "markdown": "```math_formula\nx = \\frac{-b \\pm \\sqrt{b^2 - 4ac}}{2a}\n```"}
```

Inline equation in markdown: `$(a+b)^2 = a^2 + 2ab + b^2$`

### Tables

Markdown mode:

```markdown
| Col A | Col B |
| --- | --- |
| val 1 | val 2 |
```

### Images

Blocks JSON:

```json
{"type": "image", "url": "https://example.com/photo.jpg", "markdown": "![Alt](https://example.com/photo.jpg)"}
```

Craft re-hosts the image and returns a `https://r.craft.do/` URL.

### Rich URL (Link Preview)

```json
{"type": "richUrl", "url": "https://www.youtube.com/watch?v=..."}
```

### Page / Card (Sub-pages)

```json
{"type": "page", "textStyle": "page", "markdown": "Sub-page Title"}
{"type": "page", "textStyle": "card", "markdown": "Card Title"}
```

Then insert content inside using the returned page ID as `pageId`.

### Callouts (Colored Blocks)

Require blocks JSON with `color`:

```json
{"type": "text", "color": "#00A3CB", "markdown": "<callout>💡 Info</callout>"}
```

Common colors: `#00A3CB` (blue/info), `#FF3B30` (red/warning), `#34C759`
(green/success), `#FF9500` (orange/caution), `#9862E8` (purple), `#003382`
(deep blue), `#006744` (deep green), `#864d00` (brown), `#ef052a` (bright red),
`#9ea4aa` (gray).

Callouts support inline styles inside:
`<callout>**bold** and <highlight color="yellow">highlight</highlight></callout>`

### Fonts

Set via `font` in blocks JSON: (default), `serif`, `mono`, `rounded`.

### Caption

```json
{"type": "text", "textStyle": "caption", "markdown": "<caption>Small annotation</caption>"}
```

### Task Blocks in Documents

```json
{"type": "text", "listStyle": "task", "taskInfo": {"state": "todo"}, "markdown": "- [ ] Task"}
```

States: `todo`, `done`, `canceled` — NOT "completed".

### Combination Example

```json
{
  "type": "text",
  "font": "rounded",
  "textStyle": "h3",
  "color": "#9862E8",
  "markdown": "<callout>### ✨ Purple rounded heading callout</callout>"
}
```

---

## Choosing Insert Method

| Need | Use | Why |
|------|-----|-----|
| Text, lists, headings | Markdown | Clean, auto-detects types |
| Toggle lists with children | Markdown | Only way to get indentation right |
| Code blocks, tables | Either | Markdown is simpler; JSON needs `rawCode` |
| Colored callouts | Blocks JSON | Need `color` property |
| Custom fonts | Blocks JSON | Need `font` property |
| Captions | Blocks JSON | Need `textStyle: "caption"` |
| Images, richUrl, pages | Blocks JSON | Need `type` field |
| Line styles | Blocks JSON | Need `lineStyle` |
| Math formulas | Blocks JSON | Need `language: "math_formula"` + `rawCode` |
| Mixed content | Split calls | Combine markdown + blocks JSON |

---

## Gotchas & Lessons Learned

1. **Toggle indentation**: markdown mode with 2-space indent is the only way.
   `indentationLevel` in blocks JSON is silently ignored on insert.

2. **Task state values**: `todo | done | canceled`. NOT `completed`.

3. **Position `after`/`before`**: use `siblingId` (not `blockId`).

4. **Position `end`/`start`**: use `pageId` or `date`.

5. **Code blocks in JSON mode**: require `rawCode` field. Without it you get
   a validation error.

6. **Collection item keys**: the API docs say `title` but the real field name
   is the auto-generated `contentProp` key from the schema (e.g. `_4`).
   Always `GET /collections/<id>/schema?format=json-schema-items` first
   to discover the correct keys.

7. **URL-encode search terms**: Chinese and special characters in query params
   must be URL-encoded or `curl` returns 400.

8. **Accept header**: use `application/json` for reads. `text/markdown` may 502.

9. **Document delete is soft**: goes to trash, restorable via move.
   Block delete is permanent.

10. **Large inserts**: one POST can insert many blocks. Prefer fewer larger
    writes to avoid rate limits.

11. **Image re-hosting**: Craft downloads external images and re-hosts them
    at `https://r.craft.do/`. Your original URL is replaced.

12. **Collections are experimental**: the API may change. Always read the
    schema before writing items.
Pliki w paczce (3)
  • SKILL.md 17 KB
  • _meta.json 1 KB
  • references/formatting-cheatsheet.md 2 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · LeoYeAI/openclaw-master-skills90MIT
nicsuzor/academicops100MIT
nicsuzor/academicops100MIT
shubhamgoel27/artifold100MIT
didiansyah/skills100MIT
cameronspears/claude-skills100MIT
brolag/neural-claude-code100MIT
alexiolan/craft-skills100GPL-3.0
educlopez/ui-craft90MIT

Migawka bazy z 13.11.2026 · wersja paczki 1379d0eb120f (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 90drive-cli
    Przeszukuje i czyta wybrane foldery Google Drive offline: dokumenty, arkusze, PDF i DOCX jako tekst, z tagami i notatkami.
  • 100outline
    Przeszukuje, czyta i zarządza dokumentami wiki Outline: wyszukiwanie dokumentacji, listowanie kolekcji, tworzenie i aktualizacja treści oraz eksport do Markdown.
  • 100notion-format
    Formatuje i publikuje w Notion bogate dokumenty z sekcjami, blokami kodu, tabelami, calloutami i diagramami mermaid, dobierając szablon do typu treści, jak notatki ze spotkania czy raport błędu.
  • 96notion
    Przeszukuje, czyta, tworzy i aktualizuje strony oraz bazy danych w Notion przez API.
  • 100docx
    Tworzy i edytuje dokumenty Word (.docx): nagłówki, stylizowane akapity, tabele, obrazy, nagłówki i stopki oraz formatowanie strony.
  • 98obsidian-vault-manager
    Porządkuje vault Obsidian: tworzy notatki dzienne, przenosi pliki bez psucia linków, zarządza szablonami i tagami.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.