Przejdź do treści
Biblioteka skilli
Dokumenty i biuro · Konwersja i formaty

window-schedule

/window-schedule

Tworzy rysunki okien w skali i PDF z harmonogramem z arkusza CSV lub xlsx, wraz ze stroną zamówienia dla producenta.

Licencja
MIT
Ostatnia zmiana repozytorium
27.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 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ść35 / 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
1
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

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

Licencja

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

Co sprawdzić przed instalacją
  • 1 skrypt w paczce. Przejrzyj je przed instalacją, bo Claude może je uruchomić.

Skrypty: draw_windows.py

Co robi i kiedy

Tworzy rysunki okien w skali i PDF z harmonogramem z arkusza CSV lub xlsx, wraz ze stroną zamówienia dla producenta.

Argumenty

/window-schedule [path to .csv or .xlsx]
Oryginalny opis (EN)

Use when someone asks to draw window drawings, make a window schedule PDF, render scaled window/rough-opening drawings from a spreadsheet, turn a CSV/xlsx of window sizes into to-scale architectural PDFs, or produce a window order cover sheet (shipping address, frame color, project number, per-style counts, total area in sqm/sqft/sqin). Handles dimensions in mm, cm, in, ft-in, or ft-in-fraction.

Jak działa

  1. What This Skill Does
  2. Context / Setup
  3. Steps
  4. Rendering one page per size group (universal sizes)
  5. Output
  6. Notes
Sekcje z nagłówków SKILL.md, w oryginale · 195 linii, 1 698 słów
Podgląd SKILL.md
---
name: window-schedule
description: Use when someone asks to draw window drawings, make a window schedule PDF, render scaled window/rough-opening drawings from a spreadsheet, turn a CSV/xlsx of window sizes into to-scale architectural PDFs, or produce a window order cover sheet (shipping address, frame color, project number, per-style counts, total area in sqm/sqft/sqin). Handles dimensions in mm, cm, in, ft-in, or ft-in-fraction.
argument-hint: [path to .csv or .xlsx]
disable-model-invocation: true
allowed-tools: Bash, Read, Write, Edit, AskUserQuestion
---

## What This Skill Does

Reads window sizes (rough opening + window unit) from a CSV or xlsx and produces a
to-scale architectural PDF — **one input row per page**. Each page draws the rough
opening as an outer rectangle with the window unit nested inside, dimension lines on
both, a scale bar, and a title block. By default every dimension is labelled in
**feet-inch-fraction (primary) and millimetres (secondary)**, no matter what units
the input used.

Three behaviours are opt-in via the config (all backward-compatible):
- **mm-only labels** — set `"units": "mm"` to drop ft-in and label everything in mm.
- **Window-size-only render** — leave the rough-opening pair `null` to draw just the
  unit (no outer rectangle, and no "rough opening not provided" warning).
- **Rooms list in the title block** — map a `rooms` column (a comma-separated string)
  to print "Rooms: …" wrapped under the title. This drives **one-page-per-size-group**
  schedules: one row per universal/order size, listing the rooms that take that size
  (see "Rendering one page per size group" below).
- **Window-type operation symbols** — the `style` column doubles as a window *type*:
  if its value contains `double hung`, `slider`/`sliding`, or `double hung` +
  `mullion`/`pillar`/`side-by-side`, the engine draws the matching elevation symbol
  inside the unit (meeting rail + vertical arrows for hung; meeting stile + horizontal
  arrows for slider; a to-scale center-mullion band splitting two hungs for the mullion
  case). The mullion is drawn at `mullion_mm` wide (default 90 mm, labeled on the post),
  and the two sashes size to `(width − mullion)/2`. A `fold`/`accordion` value (e.g.
  "Aluminum folding patio door — 4-panel, outswing, right stack") draws N equal panels
  with a dashed accordion zig-zag, a stack-side arrow, and an `N-PANEL FOLD · OUTSWING ·
  STACK R/L` label (panel count, stack side, and swing parsed from the text). The full
  text also prints as a "Type:" line. Any other/blank value just draws a plain unit.
- **Cover sheet** — add a `"cover"` block to prepend a summary first page: project #,
  frame color, shipping address (all optional, shown only if given), plus auto-computed
  order totals — **total window units** and (if any) **total door units** counted
  separately (a row is a *door* when its `style` has `door`/`fold`/`accordion`),
  **total area in sqm with sqft + sqin conversions**, **count-by-window-type** and
  **count-by-door-type** tables, and a by-size manifest.
- **Insect screens** — set `"screens"` to mark screened units: `"operable"` (operable
  windows only — excludes fixed `picture`/`fixed` glass and doors), `"all_windows"`, or
  `"all"` (incl. doors). Adds a **Screens required** total to the cover and a
  `Screens: Required (qty)` line to each screened unit's title block.
- **Multi-panel assemblies** — map a `layout` column (spec like
  `SL:24 | DOOR:107:hinge=R,swing=out | SL:24`) to draw an assembly of fixed sidelites
  and swing doors in one unit (mullion posts, `FIXED` lites, dashed door-swing
  triangles). Ideal for entry doors with sidelites. See [reference.md](reference.md).
- **Quote options** — map a `quote` column; truthy rows render as labeled
  **"Quote Option"** pages and are excluded from all cover totals/counts/manifest (for
  design alternatives where only one is ordered).

Input dimensions may be in any of: `mm`, `cm`, `in`, `ftin` (e.g. `2'11"`), or
`ftin_frac` (e.g. `2'10"15/16`). Everything is converted to millimetres internally.

All the parsing, conversion, and drawing lives in **`draw_windows.py`** (same folder
as this file). This skill orchestrates it: inspect → confirm mapping → draw.

## Context / Setup

- Worker script: `draw_windows.py` (in this skill's directory).
- Conversion + column-mapping details: see [reference.md](reference.md).
- Dependencies: `pandas`, `openpyxl`, `reportlab`. If a run reports missing packages,
  install them: `python3 -m pip install --quiet pandas openpyxl reportlab`.

## Steps

**0. Resolve the input file.**
Use the `$1` argument as the path if given. Otherwise look in the current directory
for a `.csv`/`.xlsx`; if there are several, ask the user which one with
AskUserQuestion. Set `SKILL_DIR` to this skill's directory (where `draw_windows.py`
lives).

**1. Inspect the file and propose a column mapping.**
Run:
```
python3 "$SKILL_DIR/draw_windows.py" inspect "<input file>"
```
This prints JSON: every sheet's headers, sample rows, a `recommended_sheet`, and a
heuristic `proposed_mapping` per sheet (room, id, qty, style, and the four dimension
columns `ro_width`/`ro_height`/`win_width`/`win_height` each with a guessed `unit`).

**2. Confirm the mapping with the user.**
Show the user the recommended sheet and proposed mapping in a compact form, e.g.:
```
Sheet: Windows
  Rough Opening W ← 'Opening width'  (cm)
  Rough Opening H ← 'Opening height' (cm)
  Window unit  W  ← 'order width'    (cm)
  Window unit  H  ← 'order height'   (cm)
  Room ← 'Room'   ID ← 'ID'   Qty ← 'Qty'   Style ← 'Style'
```
Ask the user to confirm or correct it (which sheet, which columns map to what, and
the **unit of each dimension column**). Use AskUserQuestion if a unit is unknown
(`null` in the proposal) or any dimension column is missing — never guess a unit
silently. If the file only has a window size (no rough opening) or vice-versa, that's
fine; leave the missing pair as `null` and the drawing adapts.

**3. Write the confirmed mapping config to a temp file** (e.g. `/tmp/window_schedule_config.json`):
```json
{
  "file": "<absolute path to input>",
  "sheet": "<sheet name, or omit for CSV>",
  "output": "<input dir>/<stem>_window_schedule.pdf",
  "fraction_denominator": 16,
  "units": "dual",
  "mullion_mm": 90,
  "cover": {"project": "6505-2026", "color": "Matte black", "ship_to": "123 St\nCity, ST"},
  "columns": {
    "room": "Room", "id": "ID", "qty": "Qty", "style": "Style", "rooms": null,
    "dims": {
      "ro_width":  {"col": "Opening width",  "unit": "cm"},
      "ro_height": {"col": "Opening height", "unit": "cm"},
      "win_width":  {"col": "order width",  "unit": "cm"},
      "win_height": {"col": "order height", "unit": "cm"}
    }
  }
}
```
- Set any unused identity column (room/id/qty/style/rooms) to `null` or omit it.
- Set a missing dimension pair to `null` (e.g. `"ro_width": null` for window-size-only).
- `fraction_denominator` defaults to `16`; change to `8` or `32` only if the user asks.
- Each dim `unit` is one of `mm | cm | in | ftin | ftin_frac`.
- `units` is `"dual"` (default — ft-in + mm) or `"mm"` (mm-only labels). Confirm with
  the user which they want; set `"mm"` when they say "everything in mm".
- `rooms` maps a column whose cells are a comma-separated room list; it prints as a
  wrapped "Rooms:" line in the title block. Leave `null` for normal one-window-per-row.
- `mullion_mm` (default `90`) is the to-scale width of the center mullion for
  double-hung-with-mullion types; the post is drawn at this width and labeled.
- `cover` (omit for none) prepends a cover/summary page. All keys optional:
  `project`, `color` (frame color), `ship_to` (address; split on newlines, else commas).
  The order totals, per-style counts, and area (sqm + sqft + sqin) are computed from the
  drawn rows — `qty` weights the counts and area, so map `qty` for accurate totals.
  If the user supplies a **shipping address, frame color, and/or project number** when
  invoking, put them here. `style` values drive the count-by-style table.

**4. Render the PDF.**
```
python3 "$SKILL_DIR/draw_windows.py" draw /tmp/window_schedule_config.json
```
It prints JSON: `output` path, `windows_drawn`, and any `skipped` rows (rows with no
usable dimensions). Relay the count and the output path to the user.

**5. Report.**
Tell the user the PDF path, how many windows were drawn, and list any skipped rows or
per-window warnings (e.g. "window width exceeds rough opening"). Offer to re-run with
a different unit/mapping or fraction precision if needed.

## Rendering one page per size group (universal sizes)

When the user wants **one page per distinct order/universal size** (not one per
window) — e.g. "draw the A1 window once and record the rooms that use it" — the input
needs **one row per size**, not one per window. The drawing engine does not group;
you build the grouped input first, then point the skill at it.

1. **Build a derived input** (CSV is simplest) with one row per size group, columns:
   - a label column (e.g. `label` = `A1`, `A2`, … or the room+id for one-off sizes),
   - `qty` = how many windows take that size,
   - `win_w`/`win_h` = the size to order for that group (e.g. the group's chosen/min
     order size; for a one-off, that window's own size),
   - `rooms` = the rooms that take it, e.g. `Dining Room ×8, Living Room ×4, Garage`.

   Aggregate the source sheet (read it with `pandas`/`openpyxl`) to produce this —
   group by the size-code column, count per group, and join the room names. Include
   any ungrouped one-off windows as their own single rows.

2. **Config it** as window-size-only + rooms + (usually) mm: map `id` → the label
   column, `qty` → `qty`, `rooms` → `rooms`, `win_width`/`win_height` → the size
   columns, and set both `ro_*` to `null`. Set `"units": "mm"` if requested.

3. **Render** as in step 4. Each page shows the unit drawn to scale with the label,
   qty, size, and the wrapped room list in the title block.

## Output

- A multi-page PDF at `<input dir>/<stem>_window_schedule.pdf` (or the `output` path
  in the config). One input row per page (a single window, or a size group), Letter
  portrait, drawn to a clean architectural scale (1:5 … 1:250, chosen per page to fit).

## Notes

- **Never invent dimensions.** Only draw what's in the file. Missing/zero/negative
  sizes are skipped or flagged, not fabricated.
- The window unit is centred inside the rough opening (the gap is assumed symmetric —
  the input rarely specifies side-by-side offsets).
- Scale is chosen per page so the larger of RO/window fills the drawing area; the
  exact ratio is printed and a scale bar is drawn, so the page is dimensionally honest.
- **Units:** default labels are ft-in + mm; `"units": "mm"` makes them mm-only (drawing
  ticks, scale bar, and title block all switch). Input `unit`s still convert as usual.
- **Rooms list:** a mapped `rooms` column prints a wrapped "Rooms:" line in the title
  block — keep each cell to room names (optionally with `×count`) so it stays short.
- **Verifying the PDF visually:** render with Ghostscript, not `pdftoppm` —
  `magick -density 150 'out.pdf[0]' page.png`. Some `pdftoppm` builds don't rasterize
  the base-14 fonts and show a blank-text page even though the PDF is fine (confirm
  text with `pdftotext out.pdf -`).
- For multi-sheet workbooks, always confirm the sheet — the recommended one is a guess
  based on how many dimension columns matched.
- This skill has side effects (writes a PDF) and is `disable-model-invocation: true`;
  invoke it explicitly with `/window-schedule`.
Pliki w paczce (3)
  • SKILL.md 11 KB
  • draw_windows.py 43 KB
  • reference.md 13 KB

Wersje

W bazie nie ma innych skilli o nazwie window-schedule.

Migawka bazy z 13.11.2026 · wersja paczki be3fb50ab2af (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

  • 100xlsx-to-csv
    Zamienia każdy arkusz pliku XLSX, także wieloarkuszowego, na pliki CSV, które da się od razu przeszukać i przetworzyć.
  • 100xlsx
    Tworzy, czyta, edytuje i naprawia pliki arkuszy XLSX, XLSM i CSV, z formułami, wykresami i formatowaniem.
  • 100xlsx
    Obsługuje arkusze jako wejście i wynik: analizuje dane, dodaje wykresy, czyści i łączy tabele oraz konwertuje CSV, JSON i XLSX.
  • 86xlsx-toolkit
    Tworzy, edytuje, czyści i analizuje pliki Excel i CSV z działającymi formułami i bez błędów.
  • 100adobe-anyexcel
    Konwertuje przesłany plik PDF na arkusz Excel (XLSX), w tym wyciąga z niego tabele, przez pdf_export z adobe-anypdf zamiast ręcznego budowania w openpyxl.
  • 100xlsx
    Czyta, tworzy i edytuje arkusze Excel, porządkuje nieuporządkowane tabele i dodaje kolumny, formuły, style oraz wykresy.

Uwagi i zgłoszenia

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