diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md index be1d8f5e..782688dc 100644 --- a/.github/copilot-instructions.md +++ b/.github/copilot-instructions.md @@ -9,7 +9,7 @@ This repo hosts the **workshop content** for **Copilot Workshops**, published as - `docs/` — **Source Markdown for all lessons. Edit here.** Browsable directly on github.com; no build required. - `README.md` — Workshop landing page (also the site home via `slug: index` frontmatter). - `cli/`, `vscode/`, `cloud/`, `app/` — Per-harness lessons (Copilot CLI / VS Code / Cloud agent / GitHub Copilot app). Each folder's landing page is a `README.md` (routed via a `slug:` matching the folder path). Each harness opens with its own `0-prerequisites.md` setup lesson; the CLI and VS Code harnesses set up a codespace, while the app and cloud harnesses cover the setup their flow needs (for the app, installing Node.js locally and creating the project from the template). - - `es-es/`, `ja-jp/`, `ko-kr/`, `pt-br/`, `zh-cn/` — Localized content at the locale-root paths required by Starlight. Translated pages mirror the English path beneath each locale directory; untranslated pages use Starlight's English fallback. + - `es-es/`, `ja-jp/`, `ko-kr/`, `pl-pl/`, `pt-br/`, `zh-cn/` — Localized content at the locale-root paths required by Starlight. Translated pages mirror the English path beneath each locale directory; untranslated pages use Starlight's English fallback. - `_images/` — Screenshots and diagrams (shared across all locales). - `website/` — Optional Astro + Starlight site that publishes `docs/` to GitHub Pages (loader `base: '../docs'`). Only needed to self-host or preview the rendered site. - `astro.config.mjs` — Site config including the manually maintained sidebar and the `locales` block. The legacy `/shared/0-prereqs/` → home (`/`) redirect is a full-HTML redirect page at `src/pages/shared/0-prereqs.astro` (not an `astro.config.mjs` `redirects` entry, which would emit a stub with no `` element that Pagefind can't index). Prerequisites are now per-harness (`//0-prerequisites/`), so the old shared-prereqs URL forwards to the home page. diff --git a/.github/skills/localizations/rules/pl-pl.md b/.github/skills/localizations/rules/pl-pl.md new file mode 100644 index 00000000..46e91a42 --- /dev/null +++ b/.github/skills/localizations/rules/pl-pl.md @@ -0,0 +1,194 @@ +# pl-pl + +These rules apply to **both roles**: the `translator` agent uses them as generation directives (how to write the Polish text), and the `evaluator` agent uses them as review criteria (what to check and flag). Wherever a rule says "flag" or "look for", the translator should read it as "produce text that satisfies this". + +In general, producing and evaluating translation quality requires both accuracy of meaning and natural flow. Verify that the text passes core tests for accuracy, fluency, consistency, and cultural appropriateness. + +The four core pillars are: + +- **Accuracy:** Preserve the source meaning exactly, without additions, distortions, or omissions. +- **Fluency:** Follow Polish grammar, spelling, punctuation, and idiom so the text reads as native Polish. +- **Terminology & Consistency:** Use specialized terms, names, and recurring phrases uniformly. +- **Cultural Appropriateness:** Adapt idioms, examples, register, and vocabulary for Polish-speaking developers. + +## English to Polish Localization Scenario + +English-to-Polish translation quality is best evaluated by checking case inflection, grammatical agreement, idiomatic sentence structure, consistent treatment of the reader, and established developer terminology. Avoid English calques and overly literal word-for-word renderings. + +### Key Evaluation Pillars for Polish + +- **Regional Standard:** Use standard Polish (`pl-PL`) as used in technical documentation in Poland. Prefer natural forms such as **plik**, **repozytorium**, **kliknij**, **zaloguj się**, and **poczta e-mail** / **e-mail**, according to context. +- **Reader Address and Register:** For technical documentation, use a professional, direct style with consistent second-person singular (**ty** / imperative forms such as **Uruchom**, **Otwórz**, **Wybierz**). Do not alternate between formal **Pan/Pani** and informal **ty** within a document. Past-tense and adjectival forms addressing the learner use the conventional masculine singular of Polish technical docs (**zainstalowałeś**, **użyłeś**, **Powinieneś**). Do not switch to plural-*państwo* / *oni* forms or doubled feminine/masculine pairs unless the English source explicitly requires inclusive double forms. +- **Grammatical Agreement:** Verify case, gender, number, and adjective agreement, especially around untranslated product names and code terms. Inflect surrounding Polish words correctly even when the product name stays in English. +- **Natural Syntax:** Restructure dense English noun stacks. Polish often needs prepositions, genitive constructions, or subordinate clauses rather than long sequences of nominal modifiers. +- **Punctuation:** Follow Polish punctuation rules. Prefer Polish quotation marks („ ”) in running prose when natural; do not invent capitalization after a colon unless the following text independently requires it. + +### Common Translation Mistakes to Flag + +- **English Calques:** Flag literal renderings such as *uruchomić aplikację* used where **uruchom** / **wykonaj** is clearer, or *kliknąć na* when **kliknij** is enough. Prefer natural Polish verbs for UI and terminal actions. +- **False Friends:** Check terms such as *aktualnie*, *ewentualnie*, *kontrolować*, and *aplikacja*. Depending on context, use **obecnie**, **ewentualnie/w razie potrzeby**, **sprawdzać/sterować**, and **aplikacja/program** carefully. +- **Case Errors:** English has no case system; Polish does. Flag wrong genitive/accusative/locative around nouns modified by untranslated English product names. +- **Possessive Overuse:** English repeats "your" and "its" more often than Polish. Omit possessives when the referent is clear, but preserve ownership where it affects meaning. +- **Inconsistent Imperatives:** Flag mixing **zrób** / **proszę zrobić** / **należy zrobić** without a clear pattern. Prefer direct imperatives for step-by-step instructions. + +### Practical Evaluation Framework + +| Evaluation Metric | What to Look For (English to Polish Context) | +| :--- | :--- | +| **Accuracy (dokładność)** | Are every fact, condition, number, name, and logical relationship preserved? | +| **Fluency (płynność)** | Would a Polish reader understand each sentence immediately without detecting English syntax? | +| **Style Guide (styl)** | Are case, agreement, punctuation, capitalization, and register correct? | + +## Markdown Syntaxes + +Keep Markdown delimiters attached to the text they format, while placing Polish punctuation outside or inside the formatted span according to what is semantically emphasized. Do not allow translated punctuation or articles to enter URLs, code spans, or link targets. + +- Correct: `Zapoznaj się z [**dokumentacją Node.js**](https://nodejs.org/).` +- Incorrect: `Zapoznaj się z **[dokumentacją Node.js](https://nodejs.org/).**` when the final period is not part of the link text. + +When a translated heading changes its generated slug, update every same-document link to the localized anchor. Preserve external URLs exactly. + +## Localization for Technical Documents for Developers + +Polish developer documentation should be precise and concise. Translate established concepts when the Polish term is conventional, but retain product names, API names, identifiers, commands, and widely recognized technology terms when translating them would reduce clarity. + +### Workshop Structure Conventions + +Mirror the English harness structure, but keep these Polish naming patterns established in `docs/pl-pl/`: + +- **Harness product names** + - GitHub Copilot app → **Aplikacja GitHub Copilot** (short forms: **aplikacja Copilot**, **aplikacja** when unambiguous) + - GitHub Copilot CLI → keep **GitHub Copilot CLI** / **Copilot CLI** + - Copilot Cloud Agent → **Agent chmurowy Copilot** on the locale landing; in lesson/exercise prose prefer **agent w chmurze** / **agent Copilot w chmurze** / **agenci w chmurze** (English *cloud agent* is acceptable in mixed product lists such as “Copilot Chat, Copilot CLI i Copilot cloud agent”) + - VS Code harness remains **VS Code** / **Visual Studio Code** and **GitHub Codespaces** + - **Agent Merge** stays English; agree Polish pronouns/adjectives as masculine (**który**, **go**, **sam**, **on**) +- **Lesson vs exercise labels** (do not mix within a harness) + - `docs/pl-pl/app/**` → **Lekcja** / **Lekcje**; titles like `Lekcja N - …` (ASCII hyphen) + - `docs/pl-pl/cli/**` → **Ćwiczenie** / **Ćwiczenia**; titles like `Ćwiczenie N - …` (ASCII hyphen) or `Ćwiczenie 0: …` when the English source uses a colon + - Locale landing (`docs/pl-pl/README.md`) may say **ćwiczenia** generically when referring to all harnesses together; keep **Lekcja** / **Ćwiczenie** inside each harness +- **Landing slugs:** `docs/pl-pl/README.md` → `slug: pl-pl`; harness landings → `slug: pl-pl/app`, `slug: pl-pl/cli`, etc. +- Common section titles to reuse: **Scenariusz**, **Wymagania wstępne**, **Rozpocznij**, **Podsumowanie i kolejne kroki**, **Zasoby**, **Dobre praktyki**. + +### Developer-Specific Evaluation Rules + +#### Terminology and English Terms + +- Use established equivalents such as **łańcuch** / **string** (when discussing the data type conceptually, prefer the form common in Polish developer docs), **tablica**, **zależność**, **wątek**, **instancja**, and **repozytorium**. Do not vary synonyms casually within one file. +- Keep recognized forms such as **API**, **SDK**, **framework**, **runtime**, product names, and protocol names when that is the normal developer usage. +- Preferred recurring workshop terms (follow the forms already used in `docs/pl-pl/`): + + | English | Polish workshop form | Notes | + | :--- | :--- | :--- | + | harness | **środowisko** | Workshop sense: VS Code / CLI / App / Cloud. Never leave **harness** in learner-facing prose. | + | infrastructure (scaffolding around the tool) | **infrastruktura** | Review/best-practices sense: instructions, skills, agents that shape output quality. Do **not** use **środowisko** here — that word is reserved for harness. | + | pull request | **pull request** / **PR** | Keep English; avoid **żądanie ściągnięcia**. Inflect surrounding Polish (*pull requesta*, *pull requestami*). | + | issue | **zgłoszenie** | Optional `(issues)` on first mention when clarifying GitHub Issues; keep UI labels like **When an issue is created** in English. | + | branch | **gałąź** / **gałęzie** | Prefer over English *branch* / *branchami* in prose. | + | commit | **commit** | Prefer **commit** for Git objects; Polish verb forms as needed (*commitować* only if natural). | + | merge (verb/noun) | **scal** / **scalanie** | Keep product name **Agent Merge** unchanged; masculine agreement in Polish. | + | helper (code unit) | **helper** | Keep English when naming a helper module/function (*fundament helpera*, *publishers helper*). Optional paraphrase **funkcja wspomagająca** only when not naming a specific helper. | + | custom instructions | **instrukcje niestandardowe** | Instruction files → **pliki instrukcji**; headings like **Pliki instrukcji**. | + | custom agent | **agent niestandardowy** / **agenci niestandardowi** | Agree number/gender with surrounding Polish. | + | agent skill(s) | **skill** / **skille** / **skilli** / **skillu** | Keep English root; apply Polish inflection. Prefer **skille agenta**; first mention may use **Skille agenta (agent skills)**. Titles: **Korzystanie ze skilli agenta**. Do not use **umiejętność** for the product feature. | + | slash command(s) | **polecenie slash** / **polecenia slash** | Keep **slash**; do not invent **polecenia ukośnikowe**. Prefer **polecenie** over **komenda** in prose. | + | MCP server | **serwer MCP** | Keep **MCP** and product server names (**Playwright MCP**, **GitHub MCP Server**). | + | canvas / canvases | **kanwa** / **kanwy** | | + | session | **sesja** / **sesja agenta** | | + | session mode | **tryb sesji** | Mode names **Plan**, **Interactive**, **Autopilot** stay English (UI). | + | plan mode | **tryb planowania** | | + | workspace | **obszar roboczy** | Prefer over English *workspace* in prose. | + | quick chat(s) | **szybki czat** / **szybkie czaty** | Sidebar/UI label **Quick chats** may stay English when mirroring the product surface. | + | codespace | **codespace** | Keep English lowercase in prose (*w codespace*); UI chrome **Codespaces** stays as in the product. | + | worktree | **worktree** / **git worktree** | Keep English. | + | diff | **diff** | Keep English in UI/review contexts (*widok diff*, *Przejrzyj diff*). | + | prompt | **prompt** | Keep English for the Copilot input; instructional prose around it is Polish. | + | automation(s) | **automatyzacja** / **automatyzacje** | UI labels like **Automations**, **New automation** stay English. | + | code review | **przegląd kodu** / **przegląd** | Prefer over **przeglądanie kodu**. | + +- For critical or unfamiliar jargon, the first occurrence in a file may include the English source term in parentheses when it improves lookup, for example, **Skille agenta (agent skills)** or **środowisko uruchomieniowe (runtime)**. Apply this selectively. +- Keep variables, function names, APIs, CLI commands (`npm install`), file names, and code exactly as in the source. Translate only human-language comments and explanatory prose inside code blocks. +- **Learner prompts in fenced blocks** that the user is instructed to paste into Copilot must stay in **English** so the agent receives the intended prompt. Translate surrounding instructional prose only. +- **UI chrome strings** that must match the product UI may stay in English when they mirror the English product surface. Examples from the workshop: `Use this template`, `Create a new repository`, `Home screen`, `Sessions`, `My work`, `New session`, `Toggle review panel`, `Create PR`, `Ready to merge`, `Merge pull request`, `Sign in with your browser`, `MCP servers`, `Add server`, `Popular MCP servers`, `Automations`, `Plan`, `Interactive`, `Autopilot`, `Yes, proceed`, `Quick chats`. + +#### Tone and Instructions + +- Use concise professional prose. Prefer direct instructions such as **Uruchom poniższe polecenie**. +- Address the learner with consistent second-person singular (**ty**) and masculine past-tense / modal forms common in Polish technical docs (**zainstalowałeś**, **użyłeś**, **przejrzałeś**, **Powinieneś**). Plural-*oni* / *państwo* address and feminine/masculine doublets are out of scope for this workshop unless the English source explicitly requires them. +- Prefer **polecenie** (or **zapytanie** when asking for an example/output) over **monit** for what the learner sends to Copilot (`Użyj poniższego polecenia`, `Wyślij poniższe polecenie`). English *prompt* may remain in UI sense as **pole monitu** / **interfejs** when naming the input box; do not force **monit** for instructional steps. +- Keyboard: **Wciśnij** for single keys (`Enter`); **Użyj kombinacji** for chords (`Ctrl`+`C`). +- Browser auth flows: **postępuj zgodnie z instrukcjami** (not *monitami*). +- Prefer future tense when narrating what Copilot will do next (**zabierze się za**, **zbada**, **stworzy**). +- Prefer **na podstawie zgłoszenia** when starting a session from an issue. +- Prefer instructional **Zwróć uwagę** / **Przejrzyj** / **Upewnij się** over bare **Zauważ** / **Potwierdź** where the learner must verify something. +- Avoid unnecessary courtesy formulas and repeated reader pronouns. Do not pad instructions with **proszę**. +- Preserve distinctions among requirements (**musi** / **wymagane**), recommendations (**zalecane** / **powinien**), and possibilities (**może**). Never weaken or strengthen normative language. + +#### Syntactic Readability for Code Logic + +- Put prerequisites and conditions before outcomes when that improves comprehension: **Jeśli brakuje klucza, wystąpi błąd.** +- Treat variables as grammatical units without changing them: **Tutaj `userId` identyfikuje użytkownika.** +- Avoid ambiguous pronouns after sentences containing several possible antecedents; repeat the precise noun where needed. +- Inflect Polish around untranslated English nouns correctly (*pull requesta*, *serwera MCP*, *skillu*, *sesji agenta*). + +### Quick Quality Checklist for Developer Docs + +| What to Flag (Bad) | What to Approve (Good) | Why it Matters | +| :--- | :--- | :--- | +| **"odpal `npm install`"** | **"uruchom `npm install`"** | Keeps a professional register while preserving the command. | +| **"biblioteka ładuje swoje zależności"** when ownership is unclear | **"biblioteka ładuje zależności"** | Avoids an ambiguous possessive. | +| Switching between **ty** and **Pan/Pani** | One consistent treatment | Keeps the documentation voice stable. | +| Translating `StringBuilder` | Keeping `StringBuilder` unchanged | Preserves the identifier exactly. | +| Translating a learner prompt the user must paste | Leaving the fenced prompt in English | Ensures Copilot receives the intended English prompt. | +| **"harness"** / **"żądanie ściągnięcia"** / **"umiejętność"** for agent skills | **"środowisko"** / **"pull request"** / **"skill"/"skille agenta"** | Matches workshop glossary and product language. | +| Mixing **Lekcja** and **Ćwiczenie** in one harness | **Lekcja** in app, **Ćwiczenie** in CLI | Preserves the established per-harness naming. | +| **"GitHub Copilot app"** left untranslated in prose | **"Aplikacja GitHub Copilot"** | Matches the localized product name used on landings and lessons. | +| Leaving UI labels like **Ready to merge** translated | Keeping product UI chrome in English | Learner can match on-screen controls. | +| **"Agent Merge, które/ono"** | **"Agent Merge, który/on"** | Product name takes masculine agreement in Polish. | +| **"środowisko"** for instructions/skills scaffolding | **"infrastruktura"** | Keeps **środowisko** = harness only. | +| Title **"… umiejętności agenta"** for agent skills | **"… skilli agenta"** | Product feature stays **skill**, not **umiejętność**. | + +## Evaluator Scoring Rubric + +This is the **definitive pass/fail gate** for the `evaluator` role. Criteria are split into two tiers: + +- **Tier A — Hard-fail criteria:** any material defect makes the document unusable, so these **must score 5 to pass**. +- **Tier B — Graded criteria:** scored on the 1–5 scale below; these **pass at 4 or 5**. + +A document **PASSES only when every applicable Tier A criterion scores 5 and every applicable Tier B criterion scores 4 or 5.** Otherwise it FAILS and is returned to the translator with specific notes that cite the offending source/target snippets and criterion. If the same subjective criterion still fails after **3 iterations**, escalate to a human. + +Tier B scale: + +- **5 — Excellent:** Fully meets the criterion; no issues. +- **4 — Good (pass):** At most 1–2 trivial, non-blocking nits per ~1,000 words. +- **3 — Borderline (fail):** Several noticeable issues, or any issue that changes how a sentence reads. +- **2 — Poor (fail):** Frequent or significant violations. +- **1 — Unacceptable (fail):** The criterion is largely unmet. + +### Determining Content Type + +- **Technical documentation** is content for developers/operators or any document containing code, commands, or API identifiers. Criteria 7–8 apply. +- **Non-technical content** is UI, marketing, narrative, or conversational copy without code. Criteria 7–8 do not apply, and Criterion 4 uses the audience-appropriate register. + +If otherwise non-technical content contains occasional code or links, Criterion 2 and Criterion 7 still apply to those spans. + +### Tier A — Hard-Fail Criteria (Must Score 5) + +| # | Criterion | Passes (5) when… | Fails (<5) when… | +| :-- | :--- | :--- | :--- | +| 1 | **Accuracy (dokładność)** | Meaning matches the source exactly; all facts, numbers, names, conditions, and modality are preserved. | Any mistranslation, negation flip, fabricated/dropped fact, altered number/name, or changed requirement level occurs. | +| 2 | **Markdown & Structural Integrity** | Frontmatter keys, Markdown, tables, external URLs, and heading order are preserved; localized anchors resolve; image paths point to real assets. | Any link or asset path is broken, a frontmatter key is translated, an English anchor remains after its heading changes, or Markdown/table structure is corrupted. | + +### Tier B — Graded Criteria (Must Score at Least 4) + +| # | Criterion | Scores 5 when… | Pass floor — Score 4 | Fail ceiling — Score 3 | Scores 1 when… | +| :-- | :--- | :--- | :--- | :--- | :--- | +| 3 | **Fluency (płynność)** | Reads as native `pl-PL`; grammar, case, agreement, syntax, and punctuation are correct; no calques. | At most 2 minor slips that do not impede reading. | Any awkward calque requiring rereading, or 3+ language errors. | English-shaped or ungrammatical prose is pervasive. | +| 4 | **Register & Reader Address** | Professional register and **ty**/imperative treatment fit the audience and remain uniform. | One isolated treatment slip that does not shift the perceived voice. | Two or more treatment shifts, or an audience-inappropriate tone. | Register and reader address are inconsistent throughout. | +| 5 | **Terminology & Consistency** | Terms follow `pl-PL` conventions and the workshop glossary above (including harness names and Lekcja/Ćwiczenie); each concept is rendered consistently. | One minor inconsistency remains understandable. | Two or more inconsistent renderings, a false friend, or one misleading term. | Terminology is unreliable throughout. | +| 6 | **Regional & Linguistic Naturalness** | Idioms, possessives, and vocabulary are natural for Polish without unnecessary source-language interference. | One or two harmless stylistic nits. | Several calques, ambiguous possessives, or unnatural phrasing. | The text consistently sounds translated. | +| 7 | **Code & Command Integrity** *(technical only — Tier A severity: any violation caps this at ≤2)* | Variables, identifiers, APIs, file names, and commands are unchanged; learner prompts stay English; only human-language comments are translated. | — (no trivial tolerance) | A single identifier, file name, command, or learner prompt is altered. | Code and commands are repeatedly translated or corrupted. | +| 8 | **Developer Terminology Convention** *(technical only)* | Established Polish and retained English terms match actual developer usage; over-translation is avoided. | One borderline but recognizable choice. | A forced translation or nonstandard term would confuse a developer. | Technical concepts are consistently rendered unnaturally. | + +> Criterion 7 has Tier A severity in practice: any altered command, identifier, or learner prompt fails the document. + +**Overall result:** PASS only if Criteria 1–2 equal 5 and every applicable Criterion 3–8 is at least 4, with no Criterion 7 violation. Otherwise FAIL and iterate, up to the 3-iteration escalation cap. Score each defect under the most specific criterion and do not double-penalize it. diff --git a/AUTHORING.md b/AUTHORING.md index fd226b81..d04c9f6d 100644 --- a/AUTHORING.md +++ b/AUTHORING.md @@ -16,7 +16,7 @@ copilot-workshops/ │ ├── vscode/ ← VS Code lessons (0-prerequisites.md + numbered exercises) │ ├── cloud/ ← Cloud agent lessons (0-prerequisites.md + numbered exercises) │ ├── app/ ← GitHub Copilot app lessons (setup folded into Exercise 1) -│ ├── es-es/ ja-jp/ ... ← Translated locale trees (currently the app harness) +│ ├── es-es/ ja-jp/ ko-kr/ pl-pl/ pt-br/ zh-cn/ ← Translated locale trees (app + cli) │ └── _images/ ← Screenshots and diagrams (shared across locales) ├── website/ ← Optional Astro + Starlight publisher │ ├── astro.config.mjs ← Site URL, base path, locales, sidebar diff --git a/README.md b/README.md index f86ad396..f14e819c 100644 --- a/README.md +++ b/README.md @@ -22,7 +22,7 @@ For PR/CI rules, see **[CONTRIBUTING.md](./CONTRIBUTING.md)**. - **`docs/`** — **Lesson source (plain Markdown). Edit here.** Browsable directly on github.com, no build required. - `README.md` — Workshop landing page (also the published site's home via `slug: index`). - `cli/`, `vscode/`, `cloud/`, `app/` — Per-harness lessons (Copilot CLI / VS Code / cloud agent / GitHub Copilot app). Each codespace-based harness opens with its own `0-prerequisites.md` setup lesson, and a folder `README.md` (routed via a `slug:` matching the folder) is its landing page. - - `es-es/`, `ja-jp/`, `ko-kr/`, `pt-br/`, `zh-cn/` — Translated locale trees (currently the app harness). + - `es-es/`, `ja-jp/`, `ko-kr/`, `pl-pl/`, `pt-br/`, `zh-cn/` — Translated locale trees (currently the app and CLI harnesses). - `_images/` — Screenshots and diagrams (shared across all locales). - **`website/`** — Optional Astro + Starlight site that publishes `docs/` to GitHub Pages. Only needed to self-host or preview the rendered site. - `astro.config.mjs` — Site URL, base path, `locales` block, sidebar. diff --git a/docs/pl-pl/README.md b/docs/pl-pl/README.md new file mode 100644 index 00000000..9534972b --- /dev/null +++ b/docs/pl-pl/README.md @@ -0,0 +1,43 @@ +--- +slug: pl-pl +title: "Praktyczne warsztaty z agentami GitHub Copilot" +authors: + - geektrainer + - azkel +lastUpdated: 2026-09-09 +--- + +Niedawne rozszerzenia możliwości GitHub Copilot dają programistom potężne narzędzia podczas pracy na każdym etapie cyklu życia oprogramowania (SDLC). Obejmują pracę ze zgłoszeniami, pull requestami na GitHubie, interakcję z usługami zewnętrznymi oraz oczywiście tworzenie kodu. Te warsztaty opierają się na tych funkcjach, pokazując praktyczne przypadki użycia i wskazówki, jak w pełni wykorzystać te narzędzia. + +> [!CAUTION] +> Ponieważ GitHub Copilot jest probabilistyczny, a nie deterministyczny, dokładny kod, zmienione pliki itd. mogą się różnić. W efekcie możesz zauważyć drobne różnice między zrzutami ekranu i fragmentami kodu w tych warsztatach a tym, co widzisz. To oczekiwane i wynika z natury tej klasy narzędzi. +> +> Jeśli coś wygląda na uszkodzone lub nie działa poprawnie, poproś mentora o pomoc! + +## Wybierz środowisko + +GitHub Copilot czeka na Ciebie tam, gdzie pracujesz. Wybierz środowisko dopasowane do sposobu, w jaki chcesz budować, i przejdź przez ćwiczenia implementujące zadania z backlogu Tailspin Toys. Każde środowisko zaczyna się od konfiguracji Twojej maszyny - wybierz tę, którą preferujesz. + +### 🖥️ [VS Code](../vscode/) + +GitHub Copilot w **Visual Studio Code** i GitHub Codespaces. Pracuj w trybie agenta Copilot Chat, z serwerami MCP i agentami niestandardowymi bez opuszczania edytora, którego już używasz — idealne, gdy chcesz wpleść pomoc AI bezpośrednio w IDE. + +### 💻 [Copilot CLI](cli/) + +**GitHub Copilot CLI** — asystent oparty na agentach działający w terminalu. Zainstaluj go, podłącz serwery MCP, generuj kod w trybie planowania i twórz własne skille, agentów niestandardowych oraz polecenia — wszystko z wiersza poleceń, bez przełączania się do edytora graficznego. + +### 🤖 [Copilot App](app/) + +**Aplikacja GitHub Copilot** — aplikacja desktopowa oparta na Copilot CLI. Uruchamiaj równoległe sesje agentów, przełączaj tryby sesji, współpracuj na kanwach i zarządzaj zgłoszeniami oraz pull requestami w GitHubie natywnie — wykorzystując między innymi **Agent Merge**, który tworzy pull requesty z opcją rebase, implementuje uwagi z przeglądu, poprawki CI i scala zmiany pomiędzy gałęziami. + +### ☁️ [Copilot Cloud Agent](../cloud/) + +**Agent chmurowy Copilot** — asynchroniczny partner programistyczny, który pracuje nad zgłoszeniami GitHub w tle. Przypisuj pracę, prowadź go agentami niestandardowymi, monitoruj postęp w panelu agentów i przeglądaj otwierane przez niego pull requesty. + +## Scenariusz + +Jesteś nowym programistą w Tailspin Toys, fikcyjnej firmie oferującej crowdfunding gier planszowych o tematyce deweloperskiej — ogromny rynek! Backlog zespołu jest już stworzony jako zgłoszenia w GitHubie, gotowe do podjęcia — zarówno prace funkcjonalne (np. filtrowanie i paginacja), jak i poprawa jakości (np. dostępność i standardy kodowania). Będziesz pracować iteracyjnie, eksplorując zarówno witrynę, jak i możliwości Copilota, aby dokończyć zadania. + +## Rozpocznij + +Wybierz środowisko powyżej, aby zacząć — każde rozpoczyna się od instrukcji jak skonfigurować środowisko potrzebne do rozpoczęcia pracy. diff --git a/docs/pl-pl/app/0-prerequisites.md b/docs/pl-pl/app/0-prerequisites.md new file mode 100644 index 00000000..6b1b5222 --- /dev/null +++ b/docs/pl-pl/app/0-prerequisites.md @@ -0,0 +1,86 @@ +--- +title: "Lekcja 0 - Wymagania wstępne" +description: "Przygotuj się do warsztatów z GitHub Copilot: zainstaluj Node.js dla projektu Tailspin Toys i utwórz własną kopię repozytorium na podstawie szablonu." +authors: + - geektrainer + - azkel +lastUpdated: 2026-09-09 +--- + +Aplikacja GitHub Copilot to aplikacja desktopowa — centralny hub zarówno dla Copilota, jak i GitHuba. Zapewnia szybki dostęp do zgłoszeń i pull requestów oraz oczywiście pozwala budować wykorzystując GitHub Copilot. Podczas tego warsztatu będziesz pracować lokalnie, korzystając zarówno z aplikacji Tailspin Toys opartej na Astro, jak i z aplikacji GitHub Copilot. Zanim zaczniesz, upewnijmy się, że Node.js jest zainstalowany na Twoim komputerze, a potem zainstalujemy aplikację Copilot. + +Podczas tej lekcji: + +- zainstalujesz Node.js, aby testy projektu mogły działać na Twoim komputerze. +- utworzysz własną kopię projektu Tailspin Toys wykorzystując szablon. + +## Zainstaluj Node.js + +W niektórych lekcjach agent buduje funkcje i uruchamia lokalnie zestaw testów Tailspin Toys, co wymaga **[Node.js][nodejs]** — jedynego środowiska uruchomieniowego (runtime), którego projekt potrzebuje. Zainstaluj wersję **22 lub nowszą**; bieżące wydanie **LTS** to bezpieczny wybór. + +Najprostsza opcja na każdej platformie to oficjalny instalator: + +1. W systemie operacyjnym otwórz okno terminala: Windows Terminal, terminal macOS lub to, czego zwykle używasz. +2. Uruchom poniższe polecenie, aby potwierdzić, że masz zainstalowany co najmniej Node.js 22 lub nowszy: + + ```shell + node --version + ``` + +3. Jeśli widzisz `v22` lub wyższy numer, możesz przejść do następnej sekcji! + +> [!TIP] +> Te kroki wykonaj tylko wtedy, gdy nie masz zainstalowanego Node albo potrzebujesz aktualizacji. + +4. Otwórz [stronę pobierania Node.js][node-download]. +5. Pobierz wersję **LTS** dla swojego systemu operacyjnego. +6. Uruchom instalator i zaakceptuj domyślne ustawienia. W Windows pozostaw zaznaczoną opcję **Add to PATH**. +7. Po instalacji otwórz nowe okno terminala. +8. Potwierdź instalację w nowym oknie terminala, uruchamiając: + + ```bash + node --version + ``` + +9. Powinieneś zobaczyć `v22.x.x` lub wyższą wersję. + +> [!TIP] +> Wolisz kontenery? Jeśli masz zainstalowanego **[Dockera][docker]**, możesz użyć [kontenera deweloperskiego][dev-containers] z repozytorium zamiast instalować Node.js lokalnie. W takim wypadku, nie instaluj go na lokalnym systemie operacyjnym. + +## Skonfiguruj repozytorium + +Warsztaty będą prowadzone na własnej kopii projektu Tailspin Toys. Utwórz ją teraz za pomocą [repozytorium szablonu][template-repository]. Nowe repozytorium zawiera wszystkie pliki potrzebne w tych warsztatach — w następnej lekcji podłączysz je do aplikacji. + +1. W nowym oknie przeglądarki przejdź do repozytorium tych warsztatów na GitHubie: `https://github.com/github-samples/tailspin-toys`. +2. Utwórz własną kopię repozytorium, wybierając przycisk **Use this template** na stronie repozytorium. Następnie wybierz **Create a new repository**. + + ![Przycisk Use this template z wybraną z listy rozwijanej opcją Create a new repository](../../_images/app-0-use-template.png) + +3. Jeśli uczestniczysz w warsztacie w ramach wydarzenia prowadzonego przez GitHuba lub Microsoft, postępuj zgodnie z instrukcjami mentorów. W przeciwnym razie możesz utworzyć nowe repozytorium w organizacji, w której masz dostęp do GitHub Copilot. + + ![Formularz Create a new repository z github-samples/tailspin-toys wybranym jako szablon i wypełnioną nazwą repozytorium](../../_images/app-0-create-repository.png) + +4. Zanotuj ścieżkę utworzonego repozytorium (**organization-or-user-name/repository-name**) — będziesz się do niej odwoływać później w trakcie zadań. + +> [!NOTE] +> Gdy tworzysz repozytorium z szablonu, backlog zgłoszeń (issues) GitHub jest tworzony automatycznie. Będziesz pracować na tych zgłoszeniach przez cały warsztat — nie musisz nic zgłaszać samodzielnie. + +## Podsumowanie i kolejne kroki + +Jesteś gotowy! Zainstalowałeś Node.js, aby projekt mógł się budować i być testowany na Twojej maszynie, oraz utworzyłeś własną kopię repozytorium Tailspin Toys. + +W następnym kroku zainstalujesz aplikację GitHub Copilot, podłączysz właśnie utworzone repozytorium i zapoznasz się z interfejsem aplikacji. Przejdź do [Lekcji 1 - Instalacja aplikacji GitHub Copilot][next-lesson]. + +## Zasoby + +- [Pobierz Node.js][node-download] +- [Tworzenie repozytorium z szablonu][template-repository] +- [O aplikacji GitHub Copilot][about-copilot-app] + +[next-lesson]: ../1-install-copilot-app/ +[nodejs]: https://nodejs.org/ +[node-download]: https://nodejs.org/en/download +[docker]: https://www.docker.com/products/docker-desktop/ +[dev-containers]: https://code.visualstudio.com/docs/devcontainers/containers +[template-repository]: https://docs.github.com/repositories/creating-and-managing-repositories/creating-a-template-repository +[about-copilot-app]: https://docs.github.com/copilot/concepts/agents/github-copilot-app diff --git a/docs/pl-pl/app/1-install-copilot-app.md b/docs/pl-pl/app/1-install-copilot-app.md new file mode 100644 index 00000000..8dcb01d9 --- /dev/null +++ b/docs/pl-pl/app/1-install-copilot-app.md @@ -0,0 +1,101 @@ +--- +title: "Lekcja 1 - Instalacja aplikacji GitHub Copilot" +description: "Zainstaluj aplikację GitHub Copilot, podłącz właśnie utworzone repozytorium, zapoznaj się z obszarem roboczym i wypróbuj szybki czat." +authors: + - geektrainer + - azkel +lastUpdated: 2026-09-09 +--- + +**[Aplikacja GitHub Copilot][about-copilot-app]** to aplikacja desktopowa pozwalająca budować oprogramowanie za pomocą agentów. Jest zbudowana na bazie GitHub Copilot CLI i integruje się natywnie z GitHubem, więc repozytoria, gałęzie i potoki CI działają od samego początku. Jest zaprojektowana pod przepływy, w których kierujesz kilkoma agentami równolegle, każdy we własnym izolowanym obszarze roboczym — zamiast robić całą pracę samodzielnie oraz pod automatyzację powtarzalnych zadań. Jeżeli Node.js jest już zainstalowany, a kopia projektu gotowa, kolejnym krokiem jest instalacja aplikacji i podłączenie tego repozytorium. + +Podczas tej lekcji: + +- zainstalujesz aplikację GitHub Copilot i zalogujesz się do niej. +- dodasz projekt do aplikacji wykorzystując swoje repozytorium na GitHubie. +- zapoznasz się z obszarem roboczym, w tym z backlogiem, który szablon dla Ciebie przygotował. +- wypróbujesz szybki czat, aby dowiedzieć się więcej o samej aplikacji. + +## Scenariusz + +Twój zespół wdraża agentów AI, aby przerabiać rosnący backlog. Aplikacja Copilot gwarantuje centralne miejsce do kierowania tą pracą — podejmowanie zgłoszeń (issues), uruchamianie agentów, przeglądanie zmian i scalanie pull requestów. W ramach tej lekcji zainstalujesz aplikację, podłączysz się i swobodnie rozpoczniesz rozmowę o projekcie z agentami. + +> [!NOTE] +> Wymagany jest odpowiedni plan Copilot — Copilot Student lub dowolny płatny plan (Pro, Pro+, Business lub Enterprise). Jeśli korzystasz z Copilot Business lub Copilot Enterprise, administrator musi włączyć dostęp do **Copilot CLI**, zanim będziesz w stanie poprawnie skorzystać z aplikacji. + +## Zainstaluj i skonfiguruj aplikację GitHub Copilot + +Aby korzystać z aplikacji GitHub Copilot, pierwszym krokiem — jak można się spodziewać — jest jej instalacja. Dostępne są wersje dla Windows, macOS i Linux. Zainstalujmy aplikację, uwierzytelnijmy się i dodajmy nasze repozytorium Tailspin Toys. + +1. W przeglądarce otwórz [stronę startową aplikacji GitHub Copilot][download-app]. +2. Pobierz aplikację dla swojej platformy i zainstaluj ją zgodnie z instrukcjami na stronie startowej. +3. Otwórz aplikację po instalacji. +4. Wybierz **Sign in to GitHub** i postępuj zgodnie z instrukcjami, aby się uwierzytelnić. Jeśli używasz GitHub Enterprise Server, wybierz **Use GitHub Enterprise** i wprowadź adres serwera, gdy zostaniesz o to poproszony. +5. Po uwierzytelnieniu zostaniesz zapytany o podłączenie repozytoriów. Wybierz właśnie utworzone repozytorium Tailspin Toys, które powinno mieć nazwę `/tailspin-toys`. +6. Wybierz **Continue**, aby kontynuować wprowadzenie. +7. Gdy zostaniesz poproszony o motyw, wybierz ten, który najbardziej Ci odpowiada, a następnie wciśnij **Finish**. + +> [!NOTE] +> Jeśli Twoja kopia Tailspin Toys nie pojawiła się na liście automatycznie, możesz dodać ją po zakończeniu procesu konfiguracji aplikacji. Po zakończeniu aplikacja Copilot przeniesie Cię na ekran główny. Stamtąd możesz wybrać **Choose from GitHub**, wyszukać repozytorium po nazwie (\/tailspin-toys), a następnie je wybrać. Repozytorium zostanie dodane do aplikacji Copilot! + +## Zapoznaj się z obszarem roboczym + +Gdy projekt jest już pobrany, poświęć chwilę na rozpoznanie, co jest gdzie w wyświetlanym interfejsie. Aplikacja dzieli wszystko na kilka obszarów na pasku bocznym: + +- **Sessions** — miejsce, w którym agenci wykonują pracę. Każda sesja działa we własnym izolowanym obszarze roboczym, więc możesz uruchomić kilka sesji naraz bez kolizji zmian. Pierwszą sesję rozpoczniesz w następnej lekcji. +- **Quick chats** — lekkie rozmowy do pytań i burzy mózgów, które nie potrzebują własnej gałęzi ani obszaru roboczego. Wypróbujesz jedną na końcu tej lekcji. +- **My work** — Twoje zgłoszenia i pull requesty, udostępnione dzięki **natywnej integracji z GitHubem**. Stąd możesz przeglądać i filtrować zgłoszenia oraz pull requesty, sprawdzać status CI, uruchamiać sesję ze zgłoszenia i przeglądać pull requesty — bez opuszczania aplikacji. +- **Automations** — zapisane zadania agenta uruchamiane według harmonogramu lub na żądanie. Jedną utworzysz pod koniec warsztatu. + +### Znajdź przygotowany backlog + +Ponieważ aplikacja integruje się natywnie z GitHubem, praca czekająca w repozytorium pojawia się bezpośrednio w aplikacji. Gdy utworzyłeś repozytorium, backlog zgłoszeń został dla Ciebie złożony — potwierdźmy, że tam jest. + +1. Wybierz **My work** na pasku bocznym. +2. Szablon przygotował osiem zgłoszeń w backlogu. To środowisko skupia się na poniższych trzech — potwierdź, że je widzisz: + + - Allow users to filter games by category and publisher + - Update our repository coding standards + - Implement pagination on the game list page + +3. Wybierz zgłoszenie, aby przeczytać szczegóły. Każde zgłoszenie jest też punktem startowym sesji agenta — rozpoczniesz pracę z tych zgłoszeń później w trakcie zadań. + +> [!NOTE] +> Lista elementów w My work jest automatycznie filtrowana, aby pokazywać tylko elementy z repozytoriów dodanych do aplikacji Copilot. Chcesz zobaczyć elementy pracy z innych repozytoriów? Dodaj je do aplikacji! + +## Wypróbuj szybki czat + +Dobry sposób, by oswoić się z aplikacją, to użyć jej do nauki o *samej aplikacji* — a **szybki czat** jest do tego idealnym narzędziem. Szybkie czaty pozwalają zadać pytanie lub zrobić burzę mózgów bez tworzenia gałęzi ani worktree, więc są doskonałe do szybkiego, jednorazowego pytania — bez sesji. + +1. Na pasku bocznym wybierz **+** obok **Quick chats**, aby otworzyć nowy czat. +2. Zapytaj aplikację, jak działają jej własne sesje: + + ```plaintext + How does the GitHub Copilot app use worktrees? + ``` + +3. Przeczytaj odpowiedź w widoku rozmowy. Zobaczysz, że każda sesja działa we własnym izolowanym git worktree — to właśnie pozwala uruchamiać kilku agentów równolegle bez kolizji zmian. Możesz kontynuować rozmowę lub w dowolnym momencie rozpocząć nowy czat. + +## Podsumowanie i kolejne kroki + +Gratulacje! Zainstalowałeś aplikację GitHub Copilot, podłączyłeś projekt i zbadałeś obszar roboczy. Nauczyłeś się: + +- instalować aplikację i logować się do GitHuba. +- dodawać projekt z jego repozytorium na GitHubie. +- jak używać interfejsu i znajdować przygotowany backlog w **My work**. +- używać szybkiego czatu do szybkiego, jednorazowego pytania. + +W następnym kroku rozpoczniesz pierwszą sesję agenta i wprowadzisz pierwszą zmianę w projekcie — wyświetlenie oceny za pomocą gwiazdek na kartach gier. Przejdź do [Lekcji 2 - Uruchomienie pierwszej sesji agenta][next-lesson]. + +## Zasoby + +- [O aplikacji GitHub Copilot][about-copilot-app] +- [Pierwsze kroki z aplikacją GitHub Copilot][getting-started] +- [Praca z sesjami agenta w aplikacji GitHub Copilot][agent-sessions] + +[ex0]: ../0-prerequisites/ +[next-lesson]: ../2-add-star-rating/ +[about-copilot-app]: https://docs.github.com/copilot/concepts/agents/github-copilot-app +[getting-started]: https://docs.github.com/copilot/how-tos/github-copilot-app/getting-started +[agent-sessions]: https://docs.github.com/copilot/how-tos/github-copilot-app/agent-sessions +[download-app]: https://gh.io/app diff --git a/docs/pl-pl/app/2-add-star-rating.md b/docs/pl-pl/app/2-add-star-rating.md new file mode 100644 index 00000000..71569e5a --- /dev/null +++ b/docs/pl-pl/app/2-add-star-rating.md @@ -0,0 +1,136 @@ +--- +title: "Lekcja 2 - Uruchomienie pierwszej sesji agenta" +description: "Rozpocznij pierwszą sesję agenta w aplikacji GitHub Copilot, wprowadź małą zmianę na kartach gier i scal ją przy użyciu pierwszego pull requesta." +authors: + - geektrainer + - azkel +lastUpdated: 2026-09-09 +--- + +W poprzedniej lekcji zapoznałeś się z interfejsem aplikacji i użyłeś szybkiego czatu. Teraz czas rozpocząć **sesję agenta** i wprowadzić pierwszą zmianę w projekcie. Niech będzie niewielka: gry mają już ocenę w formie gwiazdek w danych, ale karty gier na stronie głównej jej jeszcze nie pokazują. Poprosisz agenta o jej wyświetlenie, przejrzysz zmianę i scalisz ją jako pierwszy pull request. + +Podczas tej lekcji: + +- rozpoczniesz sesję agenta i poznasz strukturę sesji. +- poprosisz agenta o małą, skoncentrowaną zmianę w projekcie. +- przejrzysz zmianę w widoku diff obszaru roboczego. +- uruchomisz aplikację lokalnie, aby potwierdzić zmianę w przeglądarce. +- otworzysz i scalisz pierwszy pull request. + +## Scenariusz + +Każda gra w Tailspin Toys może mieć ocenę gwiazdkową i aktualnie pojawia się ona na stronie szczegółów gry. Karty gier na stronie głównej pokazują jednak tylko tytuł, kategorię, wydawcę i opis. Na rozgrzewkę agent powinien umożliwić wyświetlanie istniejącej oceny na każdej karcie — drobna, samodzielna zmiana, idealna na pierwszą sesję. + +## Anatomia sesji + +**Sesja** to rozmowa z agentem działająca we własnym izolowanym obszarze roboczym. Każda sesja dostaje **dedykowany git worktree i gałąź**, dzięki czemu możesz uruchomić kilka sesji naraz — jedna dodaje funkcję, inna naprawia błąd — bez kolizji zmian. Sesje pojawiają się na pasku bocznym pogrupowane według repozytorium; wybierz dowolną, aby do niej przełączyć. + +Wewnątrz sesji zobaczysz trzy elementy: **rozmowę** z agentem, **aktywność narzędzi** agenta podczas eksploracji i edycji plików oraz listę **zmienionych plików** z ich diffami. + +## Rozpocznij sesję i poproś o zmianę + +Rozpocznijmy nową sesję, aby zbadać projekt i zaimplementować funkcję. W [poprzedniej lekcji][prior-lesson] dodałeś projekt z repozytorium na GitHubie. Utworzymy nową sesję dla tego repozytorium i poprosimy o zmianę. + +1. Wróć do (lub otwórz) aplikacji GitHub Copilot. +2. Wybierz **Home screen**. +3. Upewnij się, że dla repozytorium wybrane jest `tailspin-toys`. + + ![Interfejs aplikacji GitHub Copilot z selektorem repozytorium ustawionym na tailspin-toys i selektorem modelu poniżej monitu](../../_images/app-2-start-session.png) + +4. Użyj poniższego polecenia, aby poprosić o zmianę: + + ```plaintext + On the game cards, show each game's star rating. The Game type already includes a starRating field — it's a number out of 5, or null when a game hasn't been rated yet. Display it on each card in src/components/GameCard.astro, and when starRating is null show "No rating yet" instead. Keep the change small and don't restructure the card layout. + ``` + +> [!NOTE] +> Zwróć uwagę, że monit zawierał nazwę pliku, który Copilot ma zaktualizować. Wskazanie plików nie jest wcale wymagane, ale skierowanie Copilota we właściwą stronę pomaga szybko generować kod i zmniejsza zużycie tokenów. + +5. Wciśnij Enter, aby wysłać polecenie do Copilota. + +Aplikacja Copilot zaczyna pracę od utworzenia nowego worktree — izolowanej kopii projektu. Następnie zbada projekt, lokalizując pliki potrzebne do dodania nowej funkcji, i stworzy niezbędny kod. Właśnie dodałeś nową funkcję wykorzystując aplikację Copilot! + +## Przejrzyj diff + +Wszystkie zmiany wygenerowane przez AI zasługują na przegląd przed scaleniem, nawet te małe. Zbadajmy zmiany za pomocą Copilota. + +1. W prawym górnym rogu aplikacji wybierz **Toggle review panel**. Otworzy się ekran diff ze wszystkimi oczekującymi zmianami wprowadzonymi przez Copilota. + + ![Górny pasek narzędzi aplikacji GitHub Copilot ze strzałką wskazującą przycisk Toggle review panel na prawo od Create PR](../../_images/app-2-review-panel.png) + +2. Powinieneś zauważyć kod dodany do `GameCard.astro`, głównego pliku używanego do wyświetlania szczegółów gry. Powinien być podobny do poniższego — małe pole, które wyświetla ocenę, gdy jest obecna, a gdy `starRating` ma wartość `null`, pokazuje „No rating yet”: + + ```astro + {game.starRating !== null ? ( + + ★ {game.starRating} / 5 + + ) : ( + + No rating yet + + )} + ``` + +> [!NOTE] +> Ponieważ Copilot, jak wszystkie narzędzia generatywnej AI, jest probabilistyczny, a nie deterministyczny, dokładny kod może różnić się od powyższego. Powinien jednak być względnie podobny. + +## Sprawdź zmiany + +Oczywiście nie powinniśmy tylko czytać kodu i zakładać, że działa. Powinniśmy też przetestować wszystko wizualnie! W tym celu uruchomimy aplikację za pomocą terminala, a potem potwierdzimy, że wszystko działa. Na szczęście w aplikacji Copilot jest wbudowany terminal! + +1. W panelu przeglądu po prawej stronie aplikacji Copilot wybierz **Terminal**. Jeśli nie ma przycisku **Terminal**, wybierz **+** (etykieta **Open in panel**), a następnie **Terminal**. + + ![Przycisk Terminal w panelu kontekstowym aplikacji GitHub Copilot](../../_images/app-terminal-screenshot.png) + +2. W oknie terminala wprowadź poniższe polecenie, aby uruchomić serwer deweloperski aplikacji webowej: + + ```shell + npm run dev + ``` + +3. Gdy serwer się uruchomi (zajmie to chwilę), otwórz okno przeglądarki. +4. Przejdź do http://localhost:4321. +5. Powinieneś teraz zobaczyć oceny gwiazdkowe przy wszystkich grach na stronie startowej! +6. Wróć do okna terminala. +7. Użyj kombinacji Ctrl+C, aby zatrzymać serwer deweloperski. + +## Otwórz i scal pierwszy pull request + +Zmiana wygląda dobrze — czas ją wypchnąć! Poprosisz agenta o otwarcie pull requesta, a następnie sam go przejrzysz i scalisz na github.com. Na razie tą drugą część zrobimy ręcznie. W nadchodzącej lekcji zobaczymy, jak Copilot może automatycznie wykonać część tej pracy. + +1. W prawym górnym rogu wybierz **Create PR**. +2. Jeśli zostaniesz o to poproszony, wybierz **Sign in with your browser** i postępuj zgodnie z instrukcjami, aby się uwierzytelnić. +3. Copilot zabierze się za tworzenie PR. + +Gdy PR zostanie utworzony, Copilot będzie śledzić workflow CI w repozytorium, które musi się uruchomić. Po chwili przycisk w prawym górnym rogu zmieni się na **Ready to merge**. To znak, że Twój PR jest gotowy do scalenia! + +4. Wybierz dymek **PR** tuż nad czatem, aby otworzyć PR w panelu przeglądu i zobaczyć pull request. Możesz tu przejrzeć PR w razie potrzeby. +5. Gdy będziesz gotowy, wybierz **Ready to merge**. +6. Wybierz **Merge pull request** w nowym oknie dialogowym, aby scalić pull request! + +Właśnie wypchnąłeś nową funkcję na witrynę! + +## Podsumowanie i kolejne kroki + +Rozpocząłeś pierwszą sesję agenta i wypchnąłeś pierwszą zmianę! Konkretnie: + +- rozpocząłeś sesję agenta i poznałeś strukturę sesji. +- skierowałeś agenta na małą, skoncentrowaną zmianę kart gier. +- przejrzałeś zmianę w widoku diff obszaru roboczego. +- uruchomiłeś aplikację lokalnie, aby potwierdzić ocenę gwiazdkową w przeglądarce. +- otworzyłeś pull request i sam go scaliłeś na github.com. + +W następnym kroku użyjesz aplikacji, aby dodać do repozytorium zestaw instrukcji niestandardowych — zaczynając od jednego ze zgłoszeń w backlogu. Przejdź do [Lekcji 3 - Instrukcje niestandardowe w Copilocie][next-lesson]. + +## Zasoby + +- [Praca z sesjami agenta w aplikacji GitHub Copilot][agent-sessions] +- [O aplikacji GitHub Copilot][about-copilot-app] +- [Zarządzanie zgłoszeniami i pull requestami w aplikacji GitHub Copilot][managing-issues-prs] + +[prior-lesson]: ../1-install-copilot-app/#zainstaluj-i-skonfiguruj-aplikację-github-copilot +[next-lesson]: ../3-custom-instructions/ +[agent-sessions]: https://docs.github.com/copilot/how-tos/github-copilot-app/agent-sessions +[about-copilot-app]: https://docs.github.com/copilot/concepts/agents/github-copilot-app +[managing-issues-prs]: https://docs.github.com/copilot/how-tos/github-copilot-app/managing-issues-and-pull-requests diff --git a/docs/pl-pl/app/3-custom-instructions.md b/docs/pl-pl/app/3-custom-instructions.md new file mode 100644 index 00000000..1df51e3a --- /dev/null +++ b/docs/pl-pl/app/3-custom-instructions.md @@ -0,0 +1,166 @@ +--- +title: "Lekcja 3 - Instrukcje niestandardowe w Copilocie" +description: "Dodamy do repozytorium zestaw instrukcji niestandardowych za pomocą aplikacji GitHub Copilot: zacznij od zgłoszenia w backlogu i scal zmianę jako pull request." +authors: + - geektrainer + - azkel +lastUpdated: 2026-09-09 +--- + +Kontekst jest kluczowy przy pracy z generatywną AI. Jeśli zadanie ma być wykonane w określony sposób — albo istnieje informacja kontekstowa, którą Copilot powinien znać — trzeba się upewnić, by ten kontekst był dostępny. Jednym z najpotężniejszych narzędzi są [pliki instrukcji][instruction-files], które opisują nie tylko *co* ma powstać, ale *jak* powinno być ustrukturyzowane. Podczas tej lekcji dodasz do repozytorium standard dokumentacji — i zrobisz to tak, jak będziesz wykonywać większość pracy od tej chwili: zaczynając od zgłoszenia (issue) w backlogu i pozwalając agentowi wprowadzić zmianę. + +Podczas tej lekcji: + +- zapoznasz się z tym, jak instrukcje repozytorium i pliki instrukcji ograniczone do ścieżek docierają do agenta. +- rozpoczniesz sesję ze zgłoszenia o instrukcjach w backlogu. +- poprosisz agenta o dodanie standardu dokumentacji do `.github/copilot-instructions.md`. +- przejrzysz zmianę i scalisz ją jako pull request. + +## Scenariusz + +Jak każdy dobry zespół deweloperski, Tailspin Toys ma zestaw wytycznych i wymagań dotyczących praktyk tworzenia oprogramowania. Są one następujące: + +- Dokumentacja powinna być dodawana do kodu w formie komentarzy TSDoc. +- Formatowanie powinno być udokumentowane i egzekwowane przez linting. + +Dzięki plikom instrukcji mamy gwarancję, że Copilot ma właściwe informacje, by wykonywać zadania zgodnie z tymi praktykami. + +## Pliki instrukcji + +Instrukcje niestandardowe pozwalają przekazać Copilotowi kontekst i preferencje, aby lepiej rozumiał styl pisania kodu i wymagania. To potężna funkcja, która pomaga kierować Copilota ku bardziej trafnym sugestiom i fragmentom kodu. Możesz określić preferowane konwencje kodowania, biblioteki, a nawet typy komentarzy, które lubisz w kodzie. Możesz tworzyć instrukcje dla całego repozytorium albo dla określonych typów plików — jako kontekst na poziomie zadania. + +Są dwa typy plików instrukcji: + +- `.github/copilot-instructions.md` — pojedynczy plik instrukcji wysyłany do Copilota przy **każdym** żądaniu dla repozytorium. Powinien zawierać informacje na poziomie projektu — kontekst istotny dla większości żądań czatu lub CLI wysyłanych do Copilota. Może obejmować używany stos technologiczny, przegląd tego, co budujesz, dobre praktyki i inne globalne wskazówki. +- Pliki `.github/instructions/*.instructions.md` można tworzyć dla konkretnych zadań lub typów plików. Użyj ich, by podać wytyczne dla określonych języków (np. TypeScript lub Astro) albo zadań takich jak tworzenie komponentu UI czy nowego zestawu testów jednostkowych. + +> [!NOTE] +> Copilot obsługuje też inne standardy wnoszenia wskazówek instrukcji przez AGENTS.md, CLAUDE.md i GEMINI.md, dzięki czemu Copilot zawsze ma właściwy kontekst. + +### Dobre praktyki zarządzania plikami instrukcji + +Zaawansowane metodologie tworzenia plików instrukcji wykraczają poza zakres warsztatu. Przykłady w tym projekcie pokazują jednak reprezentatywne podejście. Na wysokim poziomie: + +- W `copilot-instructions.md` trzymaj instrukcje skupione na wskazówkach projektowych, takich jak opis tego, co jest budowane, struktura projektu i globalne standardy pisania kodu. +- Używaj plików `*.instructions.md`, by podawać konkretne instrukcje dla typów plików (testy jednostkowe, komponenty Astro, warstwa danych) lub konkretnych zadań. +- Używaj języka naturalnego. Niech wskazówki będą jasne. Podawaj przykłady, jak kod powinien (i nie powinien) wyglądać. + +Nie ma jednego sposobu tworzenia plików instrukcji, tak jak nie ma jednego sposobu używania AI. Poprzez eksperymenty musisz znaleźć sposób, który najlepiej zadziała w Twoim projekcie. + +> [!TIP] +> Każdy projekt używający GitHub Copilot powinien mieć solidny zestaw plików instrukcji. Badając te w tym projekcie, możesz zauważyć pliki instrukcji dla wielu typów plików kodu. +> +> Szukasz szablonów lub punktu wyjścia? Zajrzyj do [awesome-copilot][awesome-copilot] — to repozytorium jest pełne plików instrukcji, agentów niestandardowych i innych zasobów. + +## Zbadaj pliki instrukcji niestandardowych w tym projekcie + +Poświęć chwilę na przeczytanie plików instrukcji dostarczanych z tym repozytorium — jest jeden główny `copilot-instructions.md` oraz zestaw plików `*.instructions.md` dla różnych zadań. Otwórz je w edytorze lub w interfejsie webowym GitHuba. + +1. Jeśli panel przeglądu nie jest jeszcze widoczny, otwórz go, wybierając **Toggle review panel** w prawym górnym rogu. + + ![Górny pasek narzędzi aplikacji GitHub Copilot ze strzałką wskazującą przycisk Toggle review panel na prawo od Create PR](../../_images/app-2-review-panel.png) + +2. Wybierz **+**, aby dodać nowy element do panelu przeglądu. +3. Wybierz **File**. +4. Wyszukaj `copilot-instructions.md`. +5. Wybierz `copilot-instructions.md` z listy plików, aby go otworzyć. +6. Zbadaj plik, zwracając uwagę na krótki opis projektu oraz sekcje takie jak **Agent notes**, **Code standards**, **Scripts** i **Repository Structure**. W **Code standards** zauważ zagnieżdżone wskazówki **GitHub Actions Workflows**. Dotyczą one wszelkich interakcji z Copilotem. +7. Wybierz **Show folder view**, aby otworzyć nawigator folderów. + + ![Przycisk Show folder view w panelu przeglądu z otwartym plikiem w aplikacji GitHub Copilot](../../_images/app-show-folder-view.png) + +8. Przejdź do folderu `.github/instructions` i zbadaj pliki. Zauważ, że są instrukcje dla plików Astro, warstwy danych Drizzle, testów i innych. +9. Otwórz `.github/instructions/unit-tests.instructions.md`. Zwróć uwagę na pole `applyTo` na górze — ustawia glob (względem katalogu głównego repozytorium), który określa, do których plików instrukcje się stosują. W tym wypadku pasuje każdy plik testów TypeScript (np. pasujący do `**/*.test.ts`). +10. Zwróć uwagę na instrukcje dotyczące tworzenia testów jednostkowych dla tego projektu. +11. Na koniec otwórz `.github/instructions/drizzle.instructions.md` i przewiń na dół. Przejrzyj linki do innych plików instrukcji (np. `unit-tests.instructions.md`) oraz istniejących plików w projekcie. Dzięki temu możesz dzielić większe zestawy instrukcji na mniejsze, wielokrotnego użytku pliki i wskazywać Copilotowi przykłady do naśladowania przy generowaniu kodu. (Ścieżki tam są względne wobec pliku instrukcji, a nie katalogu głównego repozytorium.) + +> [!NOTE] +> Sekcja **Code formatting requirements** w `copilot-instructions.md` dokumentuje standardy kodu w projekcie, ale nie wymaga jeszcze dokumentacji w kodzie. W kolejnych krokach dodasz reguły dotyczące komentarzy TSDoc i nagłówków komentarzy w plikach. + +## Zacznij od zgłoszenia o instrukcjach + +W poprzedniej lekcji rozpocząłeś sesję od bezpośredniego polecenia do Agenta. Większość pracy zaczyna się jednak od zgłoszenia. Utwórzmy nową sesję na podstawie zgłoszenia o aktualizacji plików instrukcji, a potem poprośmy o aktualizację. + +> [!NOTE] +> Ponieważ pliki instrukcji mają duży wpływ na kod generowany przez Copilota, należy dbać o to, by jasno go prowadziły. Pozwolenie Copilotowi na utworzenie pierwszej wersji — jak zrobisz w tej lekcji — to dobre podejście, lecz potem powinieneś samodzielnie go przejrzeć, by upewnić się, że aktualizacje spełniają wymagania. + +1. Wybierz **My work** na pasku bocznym +2. Wybierz zgłoszenie o tytule **Update our repository coding standards**, aby je otworzyć. +3. Wybierz **New session** w prawym górnym rogu, aby rozpocząć nową sesję na podstawie zgłoszenia. + + ![Widok zgłoszenia w aplikacji GitHub Copilot ze strzałką wskazującą przycisk New session w prawym górnym rogu](../../_images/app-new-session-from-issue.png) + +4. Użyj poniższego polecenia, aby poprosić Copilota o aktualizację plików instrukcji zgodnie z wymaganiami udokumentowanymi w zgłoszeniu: + + ```plaintext + Following this issue, make the updates to the instructions files in this project to meet the requirements documented. Don't create the PR quite yet! + ``` + +Copilot wprowadzi zmiany! + +## Przejrzyj zmianę + +Przeczytajmy zmiany w kodzie wprowadzone przez Copilota, a także poprośmy go o przykład kodu, który teraz będzie generował na podstawie zaktualizowanych instrukcji. + +1. Wybierz **Changes** w prawym górnym rogu, aby otworzyć zmiany w kodzie. + + ![Karty panelu sesji w aplikacji GitHub Copilot ze strzałką wskazującą kartę Changes](../../_images/app-select-changes.png) + +2. Przejrzyj zaktualizowany plik instrukcji. Upewnij się, że zawiera wytyczne dotyczące dodawania dokumentacji i komentarzy do kodu. + +> [!NOTE] +> Ponieważ AI jest probabilistyczna, a nie deterministyczna, dokładny tekst będzie się różnić. + +3. Użyj poniższego zapytania, aby poprosić Copilota o utworzenie przykładu kodu, który teraz będzie generował: + + ```plaintext + Do not make any updates, but show me what the code would look like. Based on the new instructions, if I asked Copilot to create a new library component to return all Publishers what would that code look like? + ``` + +4. Przejrzyj kod zaproponowany przez Copilota. Zwróć uwagę na komentarze TSDoc i nagłówek komentarza pliku — to dokładnie to, o co proszą zaktualizowane instrukcje. + +Zaktualizowałeś pliki instrukcji w projekcie i sprawdziłeś, jaki będzie ich wpływ! + +## Otwórz i scal pull request + +Pliki instrukcji stają się zasobami w repozytorium, czyli są współdzielone z resztą zespołu. Utwórzmy PR z naszą zmianą! + +1. W prawym górnym rogu wybierz **Create PR**. +2. Jeśli zostaniesz o to poproszony, wybierz **Sign in with your browser** i postępuj zgodnie z instrukcjami, aby się uwierzytelnić. +3. Copilot zabiera się do tworzenia PR. + +Gdy PR zostanie utworzony, Copilot będzie obserwować workflow w repozytorium, który musi się uruchomić. Po chwili przycisk w prawym górnym rogu zmieni się na **Ready to merge**. To znak, że Twój PR jest gotowy do scalenia! + +4. Wybierz **Ready to merge**. +5. Wybierz **Merge pull request** w nowym oknie dialogowym, aby scalić pull request! + +> [!NOTE] +> Gdy standard zostanie scalony z gałęzią domyślną, staje się częścią projektu dla wszystkich — i dla każdej nowej sesji. Gdy w następnej lekcji rozpoczniesz sesję filtrowania z aktualnej gałęzi domyślnej, agent będzie automatycznie stosować ten standard. Zobaczysz, że generowany TypeScript zawiera komentarze TSDoc bez pytania — mały, ale realny dowód, że instrukcje kształtują generowany kod. + +## Podsumowanie i kolejne kroki + +Zbadałeś, jak aplikacja pobiera kontekst z plików instrukcji, a następnie użyłeś sesji, by dodać i scalić standard obejmujący całe repozytorium. Konkretnie: + +- poznałeś `copilot-instructions.md` repozytorium oraz pliki `*.instructions.md` ograniczone do ścieżek. +- rozpocząłeś sesję na podstawie zgłoszenia o instrukcjach w backlogu. +- poprosiłeś agenta o dodanie standardu dokumentacji do `.github/copilot-instructions.md`. +- przejrzałeś zmianę i scaliłeś ją jako pull request. + +W następnym kroku zbudujesz funkcję filtrowania w świeżej sesji — i zobaczysz, jak Agent wdraża standard, który właśnie scaliłeś. Przejdź do [Lekcji 4 - Budowanie funkcji z Autopilot][next-lesson]. + +## Zasoby + +- [Pliki instrukcji do dostosowania GitHub Copilot][instruction-files] +- [Dostosowywanie aplikacji GitHub Copilot][customize-app] +- [Dobre praktyki tworzenia instrukcji niestandardowych][instructions-best-practices] +- [Awesome Copilot — zbiór plików instrukcji i innych zasobów][awesome-copilot] + +[next-lesson]: ../4-build-filtering/ +[instruction-files]: https://docs.github.com/copilot/customizing-copilot/about-customizing-github-copilot-chat-responses +[customize-app]: https://docs.github.com/copilot/how-tos/github-copilot-app/customize-github-copilot-app +[instructions-best-practices]: https://docs.github.com/enterprise-cloud@latest/copilot/using-github-copilot/coding-agent/best-practices-for-using-copilot-to-work-on-tasks#adding-custom-instructions-to-your-repository +[awesome-copilot]: https://awesome-copilot.github.com/ +[custom-instructions-support]: https://docs.github.com/copilot/reference/custom-instructions-support +[ui-instructions]: https://github.com/github-samples/tailspin-toys/blob/main/.github/instructions/ui.instructions.md +[astro-instructions]: https://github.com/github-samples/tailspin-toys/blob/main/.github/instructions/astro.instructions.md +[managing-issues-prs]: https://docs.github.com/copilot/how-tos/github-copilot-app/managing-issues-and-pull-requests diff --git a/docs/pl-pl/app/4-build-filtering.md b/docs/pl-pl/app/4-build-filtering.md new file mode 100644 index 00000000..f38ee9ce --- /dev/null +++ b/docs/pl-pl/app/4-build-filtering.md @@ -0,0 +1,187 @@ +--- +title: "Lekcja 4 - Budowanie funkcji z Autopilot" +description: "Zbuduj statyczną, kliencką funkcję filtrowania wykorzystując tryby Plan i Autopilot w aplikacji GitHub Copilot, zobacz, jak dziedziczy standard dokumentacji, i zweryfikuj ją skillem agenta." +authors: + - geektrainer + - azkel +lastUpdated: 2026-09-09 +--- + +Dotąd wprowadziliśmy kilka małych zmian w projekcie. Większe zmiany wymagają jednak bardziej rozbudowanego procesu. Na szczęście aplikacja GitHub Copilot jest zbudowana tak, by współpracować z istniejącymi przepływami i zapewniać, że budujemy właściwe rzeczy we właściwy sposób. To pierwsza z trzech lekcji, w których przejdziesz typowy proces tworzenia oprogramowania: zaczynając od zgłoszenia (issue), wygenerujesz nową funkcję, a skill agenta uruchomi testy walidacyjne i lintery. + +Podczas tej lekcji: + +- rozpoczniesz świeżą sesję na podstawie zgłoszenia o filtrowaniu. +- użyjesz trybu **Plan**, aby zaplanować implementację funkcji, a potem wykorzystasz **Autopilot**, aby ją zbudować. +- potwierdzisz, że wygenerowany kod stosuje standard dokumentacji wdrożony wcześniej. +- zweryfikujesz pracę skillem `quality-checks` projektu. + +## Scenariusz + +Strona główna wypisuje wszystkie gry, ale odwiedzający nie mogą zawęzić listy. Zgłoszenie o filtrowaniu wnioskuje, by umożliwić filtrowanie gier według **kategorii** i **wydawcy**. Użyjmy Copilota do zaimplementowania tej funkcjonalności. + +## Kontekst + +Wprowadzenie agentów kodujących AI do przepływu deweloperskiego nie zmienia podstaw. Jeśli już, stają się one jeszcze ważniejsze! Większość programistów stosuje przepływ zbliżony do: + +1. Otwarcie złożonego zgłoszenia ze szczegółami tego, co trzeba zrobić. +2. Utworzenie planu tego, co trzeba zbudować. +3. Zbudowanie i przegląd kodu. +4. Uruchomienie testów w celu walidacji kodu. +5. Ręczna walidacja nowej funkcjonalności. +6. Utworzenie pull requesta (PR). +7. Gdy kod zostanie przejrzany i proces ciągłej integracji zakończy się sukcesem — scalenie kodu. + +> [!NOTE] +> W zależności od zespołu i organizacji dokładne szczegóły będą się różnić. Większość będzie jednak wariacją powyższego motywu. + +Trzymając się tego standardowego podejścia, zapewniasz, że kod wygenerowany przez AI spełnia wymagania i przechodzi ten sam proces weryfikacji co kod napisany ręcznie. + +## Tryby sesji + +**Tryb sesji** kontroluje, ile autonomii ma agent. Ustawisz go z listy rozwijanej pod polem monitu i możesz zmienić w dowolnym momencie: + +- **Interactive**: Ty i agent pracujecie razem. Agent sugeruje zmiany i czeka na Twoje dane przed kontynuacją. +- **Plan**: Agent najpierw tworzy plan. Przeglądasz i zatwierdzasz plan, zanim agent go wykona. +- **Autopilot**: Agent pracuje w pełni autonomicznie — pisze kod, uruchamia testy i iteruje bez czekania na dane wejściowe. + +## Zaplanuj funkcję filtrowania + +Najlepszy moment, by wychwycić potencjalny problem, to zanim powstanie jakikolwiek kod, a najlepszy sposób to odrobina planowania z wyprzedzeniem. Planując z Copilotem, poprosisz go o wygenerowanie zestawu kroków i udokumentowanie podejścia. Następnie przejrzysz plan, wprowadzisz ewentualne sugestie usprawnień, a potem pozwolisz Copilotowi wygenerować kod na podstawie planu. + +Otwórzmy zgłoszenie, rozpocznijmy nową sesję i utwórzmy plan, przełączając się w tryb planowania i wysyłając prośbę. + +1. Wybierz **My work** z karty nawigacji. +2. Wybierz zgłoszenie o tytule **Allow users to filter games by category and publisher**. +3. Wybierz **New session** w prawym górnym rogu. + + ![Widok zgłoszenia w aplikacji GitHub Copilot ze strzałką wskazującą przycisk New session w prawym górnym rogu](../../_images/app-new-session-from-issue.png) + +4. Użyj klawiszy Shift+Tab, aż tryb wyświetli **Plan**. + + ![Pole wpisywania poleceń aplikacji GitHub Copilot ze strzałką wskazującą selektor trybu ustawiony na Plan](../../_images/app-4-plan-mode.png) + +5. Wyślij poniższe polecenie. Zgłoszenie o filtrowaniu jest już w kontekście tej sesji, bo zacząłeś od niego: + + ```plaintext + Plan the work based on the requirements documented in the issue. Please ask any clarifying questions you might have as you build the plan. + ``` + +6. Agent może zadawać dodatkowe pytania podczas budowania planu. Odpowiadaj na nie zgodnie z tym, jak zbudowałbyś funkcję. + +> [!NOTE] +> Ponieważ Copilot jest probabilistyczny, dodatkowe pytania będą się różnić. W rzeczywistości może w ogóle nie zadać pytań! To całkowicie normalne. + +7. Po zakończeniu Copilot zaproponuje podsumowanie planu. Przejrzyj plan. Powinieneś zobaczyć propozycję zbudowania zapytań, dodawania kontrolek filtrów i oczywiście testów. W razie potrzeby przekaż informację zwrotną — agent uwzględni Twoje sugestie w nowej wersji. + +## Zbuduj to z Autopilot + +Gdy plan jest gotowy, pozwólmy Copilotowi zbudować implementację! + +1. Na liście opcji w oknie dialogowym **Plan summary** wybierz opcję najbliższą **Approve and implement with autopilot**. + +Copilot zacznie pracę nad implementacją! + +> [!NOTE] +> Jeśli Copilot nie zacznie automatycznie tworzyć niezbędnego kodu, możesz go do tego skłonić poleceniami w stylu „Go ahead and start building out the plan!”. +> +> Tworzenie niezbędnych aktualizacji zajmie kilka minut. Agent edytuje i tworzy pliki, pisze i uruchamia testy oraz iteruje. To dobry moment, by zastanowić się nad tym, co już zrobiłeś w ramach warsztatów, albo napić się czegoś. + +## Przejrzyj zmiany + +Cały kod wygenerowany przez AI wymaga przeglądu przed scaleniem. Przejrzyjmy kod i uruchommy witrynę, by upewnić się, że wszystko wygląda dobrze. + +1. Wybierz **Changes** w prawym górnym rogu, aby otworzyć zmiany w kodzie. + + ![Karty panelu sesji w aplikacji GitHub Copilot ze strzałką wskazującą kartę Changes](../../_images/app-select-changes.png) + +2. Przejrzyj zmiany. Powinieneś zobaczyć nowe pliki TypeScript i Astro oraz pliki testów. Zwróć uwagę, że nowe funkcje pomocnicze zawierają komentarze TSDoc i nagłówek komentarza pliku — standard dokumentacji scalony w Lekcji 3, zastosowany automatycznie bez potrzeby dodatkowych instrukcji z naszej strony. +3. W panelu przeglądu po prawej stronie aplikacji Copilot wybierz **Terminal**. Jeśli nie ma przycisku **Terminal**, wybierz **+** (etykieta **Open in panel**), a następnie **Terminal**. + + ![Przycisk Terminal w panelu kontekstowym aplikacji GitHub Copilot](../../_images/app-terminal-screenshot.png) + +4. W oknie terminala wprowadź poniższe polecenie, aby uruchomić serwer deweloperski aplikacji webowej: + + ```shell + npm run dev + ``` + +5. Gdy serwer się uruchomi (zajmie to chwilę), otwórz okno przeglądarki. +6. Przejdź do http://localhost:4321. +7. Powinieneś teraz zobaczyć dostępne filtry na stronie startowej! +8. Jeśli coś nie wygląda dobrze, możesz poprosić Copilota o aktualizacje! +9. Gdy będziesz zadowolony, wróć do okna terminala. +10. Użyj kombinacji Ctrl+C, aby zatrzymać serwer deweloperski. + +## Zweryfikuj pracę skillem quality-checks + +Mógłbyś rzucić okiem na diff i uznać sprawę za załatwioną, ale zespół ma zdefiniowany próg jakości — i powtarzalny sposób jego sprawdzenia. + +**Skille agenta** pozwalają dać Copilotowi wskazówki, jak wykonywać powtarzalne zadania, takie jak uruchamianie testów, generowanie buildów czy tworzenie pull requestów. Skille przechowywane są w folderze z instrukcjami, skryptami i zasobami, które agent może załadować na żądanie. [Agent Skills to otwarty standard][agent-skills-repo] używany przez szereg agentów, więc ten sam skill działa w Copilot Chat w trybie agenta, Copilot cloud agent, Copilot CLI i aplikacji GitHub Copilot. + +Skille znajdują się w folderze `.github/skills` projektu albo globalnie w `~/.copilot/skills`. Każdy skill to folder zawierający plik `SKILL.md` z nagłówkiem YAML (`name` i `description`), a potem instrukcjami markdown: + +```yaml +--- +name: quality-checks +description: Run the project's test suites and linter to verify code changes are ready to commit, push, or merge. +--- +``` + +Skille mogą też zawierać podfoldery ze skryptami, zasobami i materiałami referencyjnymi. Pełną strukturę opisuje [specyfikacja agent skills][agent-skills-spec]. + +> [!TIP] +> Skille są ładowane dynamicznie. Agent decyduje, który skill pasuje, na podstawie pola `description` — jasny, scenariuszowy opis to różnica między skillem używanym a ignorowanym. + +## Zbadaj skill quality-checks + +Zbadajmy skill, by zobaczyć, co robi. + +1. Jeśli panel przeglądu nie jest jeszcze widoczny, otwórz go, wybierając **Toggle review panel** w prawym górnym rogu. + + ![Górny pasek narzędzi aplikacji GitHub Copilot ze strzałką wskazującą przycisk Toggle review panel na prawo od Create PR](../../_images/app-2-review-panel.png) + +2. Wybierz **+**, aby dodać nowy element do panelu przeglądu. +3. Wybierz **File**. +4. Wyszukaj `SKILL.md`. +5. Wybierz `SKILL.md .github/skills/quality-checks` z listy plików, aby go otworzyć. +6. Zwróć uwagę na `name` i `description`. Opis mówi agentowi *kiedy* go użyć — gdy zmiany w kodzie wymagają testów, lintingu lub weryfikacji przed commitem, pushem lub mergem. +7. Przeczytaj skill. Zwróć uwagę, że dokumentuje, który skrypt uruchamia który zestaw (testy jednostkowe, testy end-to-end Playwright, ESLint), w jakiej kolejności i jak debugować typowe awarie — dzięki temu agent uruchamia sprawdzenia po drodze zespołu zamiast zgadywać. + +## Uruchom sprawdzenia + +W tej samej sesji filtrowania poproś agenta o weryfikację pracy. Nie musisz podawać nazwy skillu — agent dopasuje go na podstawie Twojej prośby. + +1. Wróć do aplikacji Copilot. +2. Wywołaj skill bezpośrednio poleceniem `/quality-checks` i wciśnij Enter. +3. Zgodnie ze skillem agent uruchamia testy jednostkowe, linter i testy end-to-end oraz raportuje wyniki. Jeśli coś się nie powiedzie, poproś o naprawę i uruchom sprawdzenia ponownie, aż wszystko będzie zielone. +4. **Pozostaw tę sesję otwartą.** W następnej lekcji dodasz serwer Playwright MCP i użyjesz go, by zobaczyć funkcję filtrowania działającą w prawdziwej przeglądarce. + +## Podsumowanie i kolejne kroki + +Zbudowałeś prawdziwą funkcję od końca do końca i zweryfikowałeś ją względem wymagań zespołu! Konkretnie: + +- rozpocząłeś świeżą sesję na podstawie zgłoszenia o filtrowaniu na aktualnym projekcie. +- użyłeś trybu Plan do zaplanowania funkcji i Autopilot do jej zbudowania. +- potwierdziłeś, że wygenerowana funkcja pomocnicza stosuje standard dokumentacji przygotowany w Lekcji 3. +- zweryfikowałeś pracę skillem `quality-checks`. + +W następnym kroku podłączysz serwer Playwright MCP i poprosisz agenta o zbadanie funkcji filtrowania w prawdziwej przeglądarce. Przejdź do [Lekcji 5 - Testowanie z serwerem Playwright MCP][next-lesson]. + +## Zasoby + +- [Praca z sesjami agenta w aplikacji GitHub Copilot][agent-sessions] +- [O Agent Skills][about-agent-skills] +- [Dostosowywanie aplikacji GitHub Copilot][customize-app] +- [O chmurowych i lokalnych sandboxach GitHub Copilot][sandboxes] + +[ex0]: ../0-prerequisites/ +[ex2]: ../2-add-star-rating/ +[ex3]: ../3-custom-instructions/ +[next-lesson]: ../5-mcp-playwright/ +[agent-sessions]: https://docs.github.com/copilot/how-tos/github-copilot-app/agent-sessions +[about-agent-skills]: https://docs.github.com/copilot/concepts/agents/about-agent-skills +[customize-app]: https://docs.github.com/copilot/how-tos/github-copilot-app/customize-github-copilot-app +[sandboxes]: https://docs.github.com/copilot/concepts/about-cloud-and-local-sandboxes +[agent-skills-repo]: https://github.com/agentskills/agentskills +[agent-skills-spec]: https://agentskills.io/specification diff --git a/docs/pl-pl/app/5-mcp-playwright.md b/docs/pl-pl/app/5-mcp-playwright.md new file mode 100644 index 00000000..f562427c --- /dev/null +++ b/docs/pl-pl/app/5-mcp-playwright.md @@ -0,0 +1,87 @@ +--- +title: "Lekcja 5 - Testowanie z serwerem Playwright MCP" +description: "Dodaj serwer Playwright MCP do aplikacji GitHub Copilot i poproś agenta o ręczne przetestowanie funkcji filtrowania w prawdziwej przeglądarce." +authors: + - geektrainer + - azkel +lastUpdated: 2026-09-09 +--- + +W poprzedniej lekcji utworzyłeś i zweryfikowałeś funkcję filtrowania zautomatyzowanym zestawem testów projektu. Testy automatyzują walidację kodu, ale pozwolenie agentowi na potwierdzenie zachowania pozwala na znacznie lepszą walidację. Umożliwia agentowi reagowanie na problemy, które widzi w faktycznym UI, które stworzył. Zbadajmy, jak MCP daje agentom AI dostęp do zewnętrznych możliwości i dodajmy serwer Playwright MCP, aby Copilot mógł bezpośrednio wchodzić w interakcję z budowaną witryną. + +Podczas tej lekcji: + +- zrozumiesz, czym jest Model Context Protocol (MCP) i jak aplikacja GitHub Copilot go używa. +- dodasz serwer Playwright MCP z ustawień aplikacji. +- poprosisz agenta o sterowanie przeglądarką i zbadanie funkcji filtrowania. + +## Scenariusz + +Choć testy jednostkowe i end-to-end są ważne, walidacja zmian w interfejsie użytkownika wymaga faktycznej interakcji z UI. Chcesz, by Copilot korzystał z witryny, nad którą pracujesz, jak użytkownik — by dalej automatyzować wprowadzanie zmian i mieć większą pewność, że aktualizacje działają zgodnie z oczekiwaniami. + +## Czym jest Model Context Protocol (MCP)? + +[Model Context Protocol (MCP)][mcp-blog-post] określa sposób komunikacji agentów AI z zewnętrznymi narzędziami i usługami. Dzięki MCP agenci AI mogą komunikować się z zewnętrznymi narzędziami i usługami w czasie rzeczywistym. Pozwala im to uzyskiwać aktualne informacje (za pomocą zasobów) i wykonywać działania w Twoim imieniu (za pomocą narzędzi). + +Te narzędzia i zasoby są dostępne przez serwer MCP, który działa jako most między agentem AI a zewnętrznymi narzędziami i usługami. Serwer MCP zarządza komunikacją między agentem AI a zewnętrznymi narzędziami (np. istniejącymi API lub lokalnymi narzędziami jak pakiety NPM). Każdy serwer MCP reprezentuje inny zestaw narzędzi i zasobów dostępnych dla agenta AI. + +Kilka popularnych istniejących serwerów MCP: + +- **[GitHub MCP Server](https://github.com/github/github-mcp-server)**: Ten serwer zapewnia dostęp do zestawu API do zarządzania repozytoriami GitHub. Pozwala agentowi AI wykonywać działania takie jak tworzenie nowych repozytoriów, aktualizowanie istniejących oraz zarządzanie zgłoszeniami (issues) i pull requestami. +- **[Playwright MCP Server][playwright-mcp-server]**: Ten serwer zapewnia automatyzację przeglądarki za pomocą Playwright. Pozwala agentowi AI wykonywać działania takie jak nawigacja pomiędzy stronami, wypełnianie formularzy i klikanie przycisków. + +Dostępnych jest wiele innych serwerów MCP zapewniających dostęp do różnych narzędzi i zasobów. GitHub hostuje [rejestr MCP](https://github.com/mcp), aby ułatwić dostęp do tych, których możesz potrzebować, jednocześnie wspierając cały ekosystem. + +> [!CAUTION] +> Traktuj serwery MCP jak każdą inną zależność w projekcie. Przed użyciem serwera MCP dokładnie przejrzyj jego kod źródłowy, zweryfikuj wydawcę i rozważ potencjalne konsekwencje dla bezpieczeństwa rzeczy, z którymi pracujesz. Używaj tylko serwerów MCP, którym ufasz, i ostrożnie przyznawaj dostęp do wrażliwych zasobów lub operacji. + +## Dodaj serwer Playwright MCP + +Serwery MCP dodajesz i zarządzasz nimi w ustawieniach aplikacji. Aplikacja zawiera katalog popularnych serwerów, więc [serwer Playwright MCP][playwright-mcp-server] jest stosunkowo łatwy do znalezienia. + +1. Użyj kombinacji Ctrl+,, aby otworzyć stronę ustawień aplikacji Copilot. +2. Wybierz **MCP servers**. +3. W oknie wyszukiwania wpisz `Playwright`. +4. Wybierz **Playwright** z listy **Popular MCP servers**. +5. Wybierz **Add server**, aby dodać go do listy dostępnych serwerów MCP. +6. Wciśnij Esc, aby zamknąć okno ustawień. + +Dodałeś serwer Playwright MCP! + +## Poproś Copilota o zbadanie funkcji przez Playwright + +Poprośmy Copilota o ręczne przetestowanie funkcji za pomocą serwera Playwright MCP. + +1. Użyj poniższego polecenia, aby poprosić Copilota o walidację nowej funkcjonalności: + + ```plaintext + Start the dev server then use the Playwright MCP server to validate the functionality you just added exists. Use the details in the issue to ensure the newly added behavior matches the specs. + ``` + +Copilot uruchomi przeglądarkę przez serwer Playwright MCP, przejdzie przez każdy krok i zgłosi, co znalazł. Zobaczysz, jak otworzy przeglądarkę na Twoim komputerze, by wykonać zadania! + +2. Przeczytaj jego podsumowanie względem kryteriów akceptacji w zgłoszeniu. Jeśli coś wygląda nie tak, zadaj pytania uzupełniające albo wyślij go z powrotem, by naprawił kod, zanim otworzysz pull request. +3. Pozostaw tę sesję otwartą — zamkniemy ją w następnej lekcji! + +Copilot zweryfikował też funkcjonalność w przeglądarce, testując funkcję jak użytkownik. + +## Podsumowanie i kolejne kroki + +Gratulacje — użyłeś serwera Playwright MCP, by przetestować funkcję w prawdziwej przeglądarce z aplikacji GitHub Copilot! Podsumowując: + +- poznałeś, czym jest Model Context Protocol (MCP) i jak aplikacja udostępnia narzędzia MCP. +- dodałeś serwer Playwright MCP poprzez interfejs aplikacji. +- poprosiłeś agenta o sterowanie przeglądarką i zbadanie funkcji filtrowania. + +Funkcja jest zbudowana, zweryfikowana i przetestowana w działaniu. Czas ją wypchnąć — używając **Agent Merge** do otwarcia i scalenia pull requesta. Przejdź do [Lekcji 6 - Scalanie z Agent Merge][next-lesson]. + +## Zasoby + +- [What the heck is MCP and why is everyone talking about it?][mcp-blog-post] +- [Microsoft Playwright MCP Server][playwright-mcp-server] +- [Konfiguracja serwerów MCP w aplikacji GitHub Copilot][customize-app] + +[next-lesson]: ../6-agent-merge/ +[mcp-blog-post]: https://github.blog/ai-and-ml/llms/what-the-heck-is-mcp-and-why-is-everyone-talking-about-it/ +[playwright-mcp-server]: https://github.com/microsoft/playwright-mcp +[customize-app]: https://docs.github.com/copilot/how-tos/github-copilot-app/customize-github-copilot-app diff --git a/docs/pl-pl/app/6-agent-merge.md b/docs/pl-pl/app/6-agent-merge.md new file mode 100644 index 00000000..eadc9efd --- /dev/null +++ b/docs/pl-pl/app/6-agent-merge.md @@ -0,0 +1,68 @@ +--- +title: "Lekcja 6 - Scalanie z Agent Merge" +description: "Otwórz pull request filtrowania, przejrzyj go w My work i pozwól Agent Merge naprawić to, co blokuje merge, oraz przeprowadzić scalenie za Ciebie — najwyższy szczebel drabiny automatyzacji scalania." +authors: + - geektrainer + - azkel +lastUpdated: 2026-09-09 +--- + +Funkcja filtrowania jest zbudowana, zweryfikowana i jej działanie było przetestowane w przeglądarce. Ostatni krok to jej scalenie. W tych warsztatach scaliłeś już dwukrotnie — za każdym razem otwierałeś pull request i sam go scalałeś na github.com. Tym razem pozwolisz aplikacji wziąć na siebie ciężką pracę dzięki **Agent Merge**, który przeprowadza pull request przez cały cykl życia z wnętrza aplikacji. + +Podczas tej lekcji: + +- poznasz, czym jest Agent Merge i jak automatyzuje cały proces scalania. +- włączysz Agent Merge w sesji dotyczącej wdrażania filtrowania. +- zobaczysz, jak tworzy pull request, uruchamia CI i scala, gdy wszystkie warunki zostaną spełnione. + +## Scenariusz + +W ostatnich modułach zbadałeś różne poziomy automatyzacji — od tworzenia kodu po pozwolenie Copilotowi na bezpośrednią walidację UI. Aby jeszcze przyspieszyć rozwój aplikacji, Tailspin Toys chce sprawdzić, czy pull requesty, które zostały przejrzane i zweryfikowane, mogą być automatycznie scalane. + +## Przedstawiamy Agent Merge + +**Agent Merge** automatyzuje ostatnią część wdrażania pull requesta przez aplikację Copilot. Gdy go włączysz, sesja aplikacji czyta Twój pull request, zajmuje się tym, co go blokuje — naprawiając nieudane walidacje CI, odpowiadając na komentarze innych programistów, robiąc rebase w razie potrzeby — i scala go, gdy tylko GitHub na to pozwoli. Działa w tle, przetrwa restarty aplikacji i wyłącza się sam, gdy pull request zostanie scalony. + +Dotąd to Ty klikałeś **Merge pull request** na github.com. Agent Merge przenosi tę odpowiedzialność na agenta, żebyś mógł przejść do kolejnego zadania, podczas gdy on przeprowadza PR do końca. Nadal przeglądasz i zatwierdzasz pracę — agent zajmuje się tylko tą żmudną, mechaniczną częścią. + +## Użyj Agent Merge do zarządzania PR + +Przejrzałeś kod ręcznie, uruchomiłeś testy i nawet pozwoliłeś Copilotowi zwalidować UI. Czas scalić nowy kod z główną gałęzią! Pozwólmy agent merge przeprowadzić PR przez ciągłą integrację (CI) i scalić. + +1. Wróć do sesji otwartej w poprzednim module, w której dodawałeś funkcjonalność filtrowania. +2. W prawym górnym rogu wybierz listę rozwijaną obok **Create PR**. +3. Wybierz **Agent merge**, aby włączyć agent merge. + + ![Lista rozwijana Create PR w aplikacji GitHub Copilot rozwinięta, ze strzałką wskazującą opcję Agent merge](../../_images/app-enable-agent-merge.png) + +4. Tekst przycisku zmienia się teraz na **Agent merge**. +5. Wybierz przycisk **Agent merge**, aby uruchomić proces agent merge. + +Aplikacja Copilot zabierze się za tworzenie i zarządzanie PR! Zacznie od przejrzenia projektu, by ustalić, jak najlepiej utworzyć PR, a potem go stworzy. + +Po chwili zauważysz, że Copilot znów zabierze się do pracy, patrząc na warunki PR — proces CI uruchamiający wszystkie testy w repozytorium. Zgłosi status wszelkich komentarzy pozostawionych przez innych członków zespołu, walidacji do uruchomienia (proces CI) oraz tego, czy PR jest możliwy do scalenia. + +6. Pozwól agent merge scalić pull request, wybierając listę rozwijaną obok **Agent merge**, a następnie **Merge pull request**. + + ![Lista rozwijana Agent merge pokazująca dozwolone działania agenta — Address reviews, Fix CI failures, Resolve conflicts — ze strzałką wskazującą Merge pull request](../../_images/app-agent-merge-merge.png) + +7. Gdy wszystkie procesy CI będą zielone (czyli testy przeszły), Copilot scali pull request! + +## Podsumowanie i kolejne kroki + +Zautomatyzowałeś kilka części procesu deweloperskiego, w tym generowanie kodu, testowanie i walidację, a teraz także proces pull request. W tej lekcji: + +- poznałeś, czym jest Agent Merge i jak automatyzuje cykl życia scalania. +- włączyłeś Agent Merge w sesji filtrowania. +- zobaczyłeś, jak tworzy pull request, uruchamia CI i scala, gdy wszystko było zielone. + +W następnym kroku zbadasz **kanwy** — bogatszy sposób planowania i wizualizacji pracy z agentem. Przejdź do [Lekcji 7 - Planowanie z kanwami][next-lesson]. + +## Zasoby + +- [Zarządzanie zgłoszeniami i pull requestami w aplikacji GitHub Copilot][managing-issues-prs] +- [O aplikacji GitHub Copilot][about-copilot-app] + +[next-lesson]: ../7-canvases/ +[managing-issues-prs]: https://docs.github.com/copilot/how-tos/github-copilot-app/managing-issues-and-pull-requests +[about-copilot-app]: https://docs.github.com/copilot/concepts/agents/github-copilot-app diff --git a/docs/pl-pl/app/7-canvases.md b/docs/pl-pl/app/7-canvases.md new file mode 100644 index 00000000..b4b6df5e --- /dev/null +++ b/docs/pl-pl/app/7-canvases.md @@ -0,0 +1,128 @@ +--- +title: "Lekcja 7 - Planowanie z kanwami" +description: "Utwórz współdzieloną, sterowaną agentem kanwę w aplikacji GitHub Copilot, aby planować i śledzić pracę razem z agentem." +authors: + - geektrainer + - azkel +lastUpdated: 2026-09-09 +--- + +Dotąd kierowałeś agentami przez czat. Ale wiele pracy nie żyje w rozmowie — żyje na tablicy, w dokumencie albo na liście zadań. **Kanwy** dają Tobie i agentowi współdzieloną powierzchnię właśnie do takiej pracy, bezpośrednio w aplikacji. Podczas tej lekcji utworzysz prostą kanwę do planowania i śledzenia backlogu, nad którym pracowałeś. + +Podczas tej lekcji: + +- zrozumiesz, czym jest kanwa i kiedy jej używać. +- utworzysz współdzieloną kanwę tablicy Kanban do zarządzania backlogiem. +- zapiszesz kanwę w repozytorium i udostępnisz ją dla zespołu. +- otworzysz kanwę w nowej sesji i zaczniesz z niej pracę. + +## Scenariusz + +Patrzenie na listę zgłoszeń (issues) może być przytłaczające, nawet w spokojniejszym okresie życia projektu. Programiści Tailspin Toys szukali narzędzia, które pozwoliłoby szybko przeglądać zgłoszenia i zaczynać nad nimi pracę w aplikacji Copilot. + +## Czym jest kanwa? + +[Kanwa][canvas-docs] to współdzielona, interaktywna powierzchnia dla całej wykonanej pracy w projekcie — planu, tablicy zarządzania backlogiem, listy wydań, pulpitu lub dokumentów. Choć czat świetnie opisuje intencję i pomaga weryfikować niejasności, większość pracy dzieje się na *powierzchni*. Kanwy pozwalają współpracować z agentem bezpośrednio na tej powierzchni. + +Kanwy są **dwukierunkowe**: agent może aktualizować kanwę podczas pracy, a Ty możesz edytować tę samą powierzchnię samodzielnie. Gdy tworzysz kanwę, agent buduje ją na podstawie Twojego polecenia i przepływu pracy, a Ty możesz prosić o dodanie, usunięcie lub zmianę możliwości w trakcie. Po utworzeniu kanwa otwiera się w prawym panelu bocznym aplikacji. + +Typowe przykłady: + +- **Kanwy Markdown** do planowania dnia i priorytetyzacji zgłoszeń oraz pull requestów. +- **Agentowe tablice kanban**, na których ludzie i agenci dodają karty i przesuwają pracę między kolumnami. +- **Tablice zarządzania zgłoszeniami**, które podsumowują najważniejsze zgłoszenia i powtarzające się tematy w repozytorium. + +## Po co używać kanwy? + +Sięgnij po kanwę, gdy zadanie wymaga struktury, iteracji i weryfikacji, a sam czat nie wystarcza. Kanwa pozwala: + +- oprzeć pracę agenta na rzeczywistym artefakcie pasującym do Twojego przepływu. +- kierować lub korygować pracę bezpośrednio na współdzielonej powierzchni, a potem pozwolić agentowi kontynuować od Twoich zmian. +- śledzić postęp jako widoczne zmiany w całym produkcie, a nie tylko odpowiedzi w czacie. + +## Utwórz kanwę do śledzenia pracy + +Wdrożyłeś sporo rzeczy: ocena gwiazdkowa, standard dokumentacji i funkcję filtrowania - wszystkie są już scalone. Ale w backlogu nadal są elementy. Utwórzmy kanwę, by szybko zaplanować pracę. + +1. Wróć do (lub otwórz) aplikacji GitHub Copilot. +2. Wybierz **Home screen**. +3. Upewnij się, że dla repozytorium wybrane jest `tailspin-toys`. +4. W polu polecenia użyj poniższego tekstu, aby utworzyć kanwę spełniającą potrzeby: + + ```plaintext + Create a basic Kanban board canvas that allows me to quickly triage work. Highlight the three issues which are most likely to need attention right now, with the remainder in a second section down below. The top three cards should include a description of the issue's content and a justification of why they're at the top of the list. Each issue should have a button that allows me to add it to the current context for the current session so I can get to work on it straightaway. + ``` + +Copilot zabierze się za tworzenie kanwy! + +> [!NOTE] +> Zajmie to kilka minut. Ponieważ to skomplikowane zadanie, możesz nie być zadowolony z pierwszej wersji. Możesz wysyłać kolejne polecenia, by zbudować narzędzie swoich marzeń! + +## Zapisz kanwę i scal ją z repozytorium + +Kanwy mogą stać się zasobami w repozytorium, tak jak pliki instrukcji i skille. Poprośmy Copilota o dodanie jej do repozytorium i scalenie, by cały zespół mógł z niej korzystać. + +1. W tej samej sesji poproś Copilota o zapisanie kanwy w repozytorium poniższym poleceniem: + + ```plaintext + Let's save this canvas definition to the repository so I can share it with my development team + ``` + +2. Gdy Copilot zapisze pliki kanwy, wybierz listę rozwijaną obok **Create PR** w prawym górnym rogu. +3. Wybierz **Agent merge**, aby włączyć agent merge. + + ![Lista rozwijana Create PR w aplikacji GitHub Copilot rozwinięta, ze strzałką wskazującą opcję Agent merge](../../_images/app-enable-agent-merge.png) + +4. Tekst przycisku zmienia się teraz na **Agent merge**. +5. Wybierz przycisk **Agent merge**, aby uruchomić proces agent merge. + +Aplikacja Copilot rozpocznie proces tworzenia i zarządzania PR. Zacznie od przejrzenia projektu, by ustalić, jak najlepiej utworzyć PR, a potem go stworzy. + +Po chwili zauważysz, że Copilot znów zabierze się do pracy, patrząc na warunki PR — proces CI uruchamiający wszystkie testy w repozytorium. Zgłosi status wszelkich komentarzy pozostawionych przez innych członków zespołu, walidacji do uruchomienia (proces CI) oraz tego, czy PR jest możliwy do scalenia. + +6. Pozwól agent merge scalić pull request, wybierając listę rozwijaną obok **Agent merge**, a następnie **Merge pull request**. + + ![Lista rozwijana Agent merge pokazująca dozwolone działania agenta — Address reviews, Fix CI failures, Resolve conflicts — ze strzałką wskazującą Merge pull request](../../_images/app-agent-merge-merge.png) + +7. Poczekaj, aż wszystkie procesy CI przejdą (staną się zielone). Gdy to się stanie, Copilot automatycznie scali pull request! + +Utworzyłeś nową współdzieloną kanwę dla zespołu! + +## Pracuj na kanwie + +Gdy kanwa jest utworzona, rozpocznijmy nową sesję i użyjmy jej! + +1. W aplikacji Copilot rozpocznij nową sesję, wybierając **New session** obok **tailspin-toys**. +2. Poproś Copilota o otwarcie kanwy zadań poniższym poleceniem: + + ```plaintext + Open the triage issues canvas + ``` + +3. Powinieneś zauważyć, że kanwa, którą zbudowałeś, jest teraz otwarta w tej nowej sesji! +4. Wybierz **Add to current context** na jednym ze zgłoszeń, które najbardziej Cię interesuje. +5. Copilot zabierze się za pracę nad zgłoszeniem! + +Użyłeś utworzonej kanwy, by usprawnić proces deweloperski. + +## Podsumowanie i kolejne kroki + +Utworzyłeś współdzieloną powierzchnię, na której Ty i agent możecie współpracować! W ramach tej lekcji: + +- poznałeś, czym są kanwy i kiedy ich używać. +- utworzyłeś z agentem współdzieloną kanwę tablicy Kanban do zarządzania zadaniami. +- zapisałeś i scaliłeś kanwę z repozytorium za pomocą Agent Merge. +- otworzyłeś kanwę w nowej sesji i użyłeś jej do rozpoczęcia pracy. + +Gdy backlog jest widoczny, zrób krok wstecz, by przejrzeć wszystko, co zbudowałeś, i dokąd iść dalej. Przejdź do [Lekcji 8 - Podsumowanie i kolejne kroki][next-lesson]. + +## Zasoby + +- [Praca z rozszerzeniami kanwy w aplikacji GitHub Copilot][canvas-docs] +- [Kanwy na Awesome Copilot][awesome-copilot-canvases] +- [O aplikacji GitHub Copilot][about-copilot-app] + +[next-lesson]: ../8-review/ +[canvas-docs]: https://docs.github.com/copilot/how-tos/github-copilot-app/working-with-canvas-extensions +[awesome-copilot-canvases]: https://awesome-copilot.github.com/extensions/ +[about-copilot-app]: https://docs.github.com/copilot/concepts/agents/github-copilot-app diff --git a/docs/pl-pl/app/8-review.md b/docs/pl-pl/app/8-review.md new file mode 100644 index 00000000..e5df99bb --- /dev/null +++ b/docs/pl-pl/app/8-review.md @@ -0,0 +1,84 @@ +--- +title: "Lekcja 8 - Podsumowanie i kolejne kroki" +description: "Podsumuj warsztaty z aplikacją GitHub Copilot, zautomatyzuj powtarzalną pracę i odkryj, jakie powinny być następne kroki." +authors: + - geektrainer + - azkel +lastUpdated: 2026-09-09 +--- + +W ostatnich lekcjach przeprowadziłeś funkcjonalność aplikacji od pomysłu do scalenia za pomocą aplikacji GitHub Copilot, w tym: + +- podłączenie repozytorium i zapoznanie się z interfejsem aplikacji oraz przygotowanym backlogiem. +- rozpoczynanie sesji od bezpośredniego polecenia i na podstawie zgłoszeń (issues) oraz używanie trybów Plan i Autopilot do sterowania pracą agenta. +- prowadzenie agenta instrukcjami niestandardowymi i wielokrotnego użytku skillem. +- testowanie pracy serwerem Playwright MCP w prawdziwej przeglądarce. +- współpracę z agentem na współdzielonej kanwie. +- wypychanie zmian za pomocą automatyzacji scalania — od samodzielnego scalania na github.com po scalenie pull requesta przez **Agent Merge**. + +Zautomatyzujmy powtarzalną pracę, omówmy dobre praktyki i zobaczmy, dokąd iść dalej. + +## Zautomatyzuj powtarzalną pracę + +Aplikacja może uruchamiać agentów według harmonogramu lub na żądanie przez **automatyzacje** — świetne do rutynowych zadań, takich jak walidacja nowych zgłoszeń lub podsumowanie niedawnej aktywności. Utwórzmy prostą, która nie będzie wprowadzała trwałych zmian. + +1. Wybierz **Automations** na pasku bocznym, a następnie **New automation**. +2. Nadaj nazwę, np. `Recap my recent work`. +3. Wybierz wyzwalacz. **Manual** pozwala uruchamiać na żądanie; **On a schedule** uruchamia automatycznie; **When an issue is created** reaguje na nowe zgłoszenia. W tej lekcji wybierz **Manual**. +4. Wprowadź polecenie tylko do odczytu, by automatyzacja nic nie zmieniała, na przykład: + + ```plaintext + Summarize the pull requests merged in this repository over the last week, and list any issues still open in the backlog. + ``` + +5. Wybierz projekt (repozytorium Tailspin Toys) i utwórz automatyzację. +6. Uruchom ją na żądanie, by zobaczyć wynik. + +> [!TIP] +> Automatyzacje mogą działać lokalnie lub w chmurze. Włącz **Run in the cloud** i wybierz **Tools**, których automatyzacja może używać, gdy chcesz, by działała bez nadzoru według harmonogramu. Trzymaj zaplanowane automatyzacje w ograniczonym zakresie i nieniszczące, dopóki nie zaufasz ich wynikom. + +## Dobre praktyki + +Przy każdym narzędziu AI infrastruktura wokół niego determinuje jakość tego, co otrzymujesz. Pliki instrukcji, skille i agenci niestandardowi odegrały rolę w tym warsztacie — inwestuj w nie i wykorzystuj ponownie między sesjami. + +Dopasuj **tryb i model** do zadania. Używaj **Plan**, by przemyśleć podejście przed budowaniem, **Interactive**, by na bieżąco rozmawiać z agentem przy złożonych zmianach, a **Autopilot** tylko przy dobrze opisanych, wyizolowanych zadaniach. Wybierz szybszy model do rutynowych edycji albo bardziej zdolny model z większymi możliwościami rozumowania do złożonej pracy — dopasuj wybór do konkretnego zadania. + +Kontekst nadal ma znaczenie tak samo jak infrastruktura. Jasne opisanie *co* ma powstać, *dlaczego* i *jak* istotnie zmienia wynik. Szybkie czaty to świetne miejsce, by określić zakres pomysłu, zanim przeniesiesz się do pełnej sesji. + +## Więcej do odkrycia + +Poznałeś podstawowy tryb pracy z agentami. Kilka kolejnych funkcjonalności wartych uwagi: + +- **Quick chats** do szybkich, jednorazowych pytań, które nie potrzebują pełnej sesji. +- **Rubber duck**, by przedyskutować problem i uzyskać wartościową informację zwrotną przed budowaniem. +- [**Agenci niestandardowi**][custom-agents], by zdefiniować rolę, jej narzędzia i instrukcje do powtarzalnej, specjalistycznej pracy. +- [`/chronicle`][chronicle], by wygenerować narrację tego, co wydarzyło się w sesji. +- [Własny klucz (BYOK)][byok], by używać modeli od własnego dostawcy, w tym lokalnych modeli przez Ollama, Foundry Local lub LM Studio. +- [Sandboxy chmurowe][sandboxes], by uruchamiać sesje w izolowanym środowisku hostowanym przez GitHuba. +- [Deep linki][deep-links], by otworzyć aplikację bezpośrednio w repozytorium, sesji lub poleceniu. + +## Kolejne kroki + +Najlepszy sposób, by poprawić swoje umiejętności pracy z każdym narzędziem, to nadal go używać! Używaj go do kodu produkcyjnego, hobbystycznego, do małej aplikacji, o której myślisz od lat, ale nigdy nie doszedłeś do zbudowania. Dziel się wnioskami z zespołem i ucz się od nich. I jak zawsze — czytaj dokumentację. + +Jeśli chcesz poznać więcej ekosystemu GitHub Copilot, zajrzyj do [środowiska VS Code](../../vscode/), [środowiska Copilot CLI](../../cli/) lub [środowiska agenta chmurowego](../../cloud/). + +## Zasoby + +- [O aplikacji GitHub Copilot][about-copilot-app] +- [Pierwsze kroki z aplikacją GitHub Copilot][getting-started] +- [Dostosuj aplikację GitHub Copilot][customize] +- [Używanie automatyzacji][using-automations] +- [Praca z rozszerzeniami kanwy][canvas-docs] +- [O chmurowych i lokalnych sandboxach][sandboxes] + +[about-copilot-app]: https://docs.github.com/copilot/concepts/agents/github-copilot-app +[getting-started]: https://docs.github.com/copilot/how-tos/github-copilot-app/getting-started +[customize]: https://docs.github.com/copilot/how-tos/github-copilot-app/customize-github-copilot-app +[using-automations]: https://docs.github.com/copilot/how-tos/github-copilot-app/using-automations +[canvas-docs]: https://docs.github.com/copilot/how-tos/github-copilot-app/working-with-canvas-extensions +[sandboxes]: https://docs.github.com/copilot/concepts/about-cloud-and-local-sandboxes +[chronicle]: https://docs.github.com/copilot/how-tos/copilot-cli/use-copilot-cli/chronicle +[custom-agents]: https://docs.github.com/copilot/concepts/agents/cloud-agent/about-custom-agents +[byok]: https://docs.github.com/copilot/how-tos/github-copilot-app/use-byok-models +[deep-links]: https://docs.github.com/copilot/how-tos/github-copilot-app/open-with-deep-links diff --git a/docs/pl-pl/app/README.md b/docs/pl-pl/app/README.md new file mode 100644 index 00000000..e426d2e3 --- /dev/null +++ b/docs/pl-pl/app/README.md @@ -0,0 +1,59 @@ +--- +slug: pl-pl/app +title: "Aplikacja GitHub Copilot" +authors: + - geektrainer + - azkel +lastUpdated: 2026-09-09 +--- + +[**Aplikacja GitHub Copilot**](https://docs.github.com/copilot/concepts/agents/github-copilot-app) to aplikacja desktopowa oparta na Copilot CLI, która umożliwia rozwój kodu sterowany agentami w jednym, skoncentrowanym obszarze roboczym. Dodaje równoległe sesje agentów, przełączalne tryby sesji, współdzielone kanwy oraz natywne zarządzanie zgłoszeniami (issues) i pull requestami GitHub — w tym opcję **Agent Merge**, który przeprowadza pull request przez rebase za Ciebie, uwzględniając uwagi od innych programistów, poprawki wynikające z walidacji CI i scalenie kodu. + +W ramach tych lekcji zainstalujesz aplikację i skonfigurujesz projekt, a następnie zapoznasz się z interfejsem aplikacji oraz backlogiem, który szablon dla Ciebie przygotował. Zaczniesz od małej zmiany — dodania oceny w formie gwiazdek — potem dodasz zestaw instrukcji niestandardowych na podstawie zgłoszonego w backlogu zgłoszenia, zbudujesz funkcję filtrowania w izolowanej sesji agenta i zweryfikujesz ją za pomocą skillu wielokrotnego użytku. Dodasz serwer Playwright MCP, aby zbadać funkcję w prawdziwej przeglądarce, a następnie przejrzysz metody automatyzacji scalania kończącej się tym, że **Agent Merge** scali Twój pull request. Na koniec będziesz współpracować na współdzielonej kanwie i zautomatyzujesz powtarzalną pracę — pełna pętla od pomysłu do scalonej funkcji. + +## Lekcje + +| Lekcja | Temat | Opis | +|--------|-------|------| +| [0. Wymagania wstępne][ex0] | Konfiguracja | Zainstaluj Node.js i utwórz swoją kopię projektu Tailspin Toys | +| [1. Instalacja aplikacji Copilot][ex1] | Konfiguracja | Zainstaluj aplikację, podłącz projekt i zapoznaj się z interfejsem | +| [2. Uruchomienie pierwszej sesji agenta][ex2] | Pierwsza zmiana | Rozpocznij sesję i wypchnij małą zmianę przy użyciu pierwszego pull requesta | +| [3. Instrukcje niestandardowe w Copilocie][ex3] | Kontekst | Dodaj standard dokumentacji na podstawie zgłoszenia i scal go | +| [4. Budowanie funkcji z Autopilot][ex4] | Główna funkcja | Użyj Plan i Autopilot do zbudowania filtrowania, potem zweryfikuj je skillem | +| [5. Testowanie z Playwright MCP][ex5] | Narzędzia zewnętrzne | Dodaj serwer Playwright MCP i przetestuj funkcjonalność w przeglądarce | +| [6. Scalanie z Agent Merge][ex6] | Scalanie | Pozwól Agent Merge naprawić i scalić pull request filtrowania | +| [7. Planowanie z kanwami][ex7] | Współpraca | Utwórz współdzieloną kanwę do planowania i śledzenia pracy | +| [8. Podsumowanie i kolejne kroki][ex8] | Podsumowanie | Zautomatyzuj powtarzalne zadania i odkryj, co dalej | + +## Wymagania wstępne + +Przed udziałem w tych warsztatach upewnij się, że masz: + +- [ ] Konto GitHub z aktywnym planem **Copilot Student, Pro, Pro+, Business lub Enterprise** +- [ ] Komputer z **macOS, Linux lub Windows** +- [ ] [Zainstalowany Git][install-git] na komputerze + +> [!TIP] +> Brak płatnego planu? Zweryfikowani studenci mogą otrzymać GitHub Copilot za darmo przez [GitHub Education][callout-student-plan-education]. Plan **Copilot Student** obejmuje agenta, MCP, przegląd kodu i funkcje Copilot CLI używane w tych warsztatach — więc możesz ukończyć każdą ze ścieżek. + +> [!NOTE] +> Ponieważ aplikacja Copilot działa na Twoim komputerze, a nie w codespace, [Lekcja 0][ex0] zaczyna się od instalacji Node.js i utworzenia kopii projektu przed instalacją aplikacji. + +> [!NOTE] +> Jeśli korzystasz z Copilot Business lub Copilot Enterprise, administrator musi włączyć funkcję **Copilot CLI**, zanim będziesz mógł używać aplikacji. + +## Rozpocznij + +**[Zacznij od Lekcji 0: Wymagania wstępne →][ex0]** + +[ex0]: 0-prerequisites/ +[ex1]: 1-install-copilot-app/ +[ex2]: 2-add-star-rating/ +[ex3]: 3-custom-instructions/ +[ex4]: 4-build-filtering/ +[ex5]: 5-mcp-playwright/ +[ex6]: 6-agent-merge/ +[ex7]: 7-canvases/ +[ex8]: 8-review/ +[install-git]: https://github.com/git-guides/install-git +[callout-student-plan-education]: https://github.com/education/students diff --git a/docs/pl-pl/cli/0-prerequisites.md b/docs/pl-pl/cli/0-prerequisites.md new file mode 100644 index 00000000..bbd4c350 --- /dev/null +++ b/docs/pl-pl/cli/0-prerequisites.md @@ -0,0 +1,70 @@ +--- +title: "Ćwiczenie 0 - Wymagania wstępne" +authors: + - geektrainer + - azkel +lastUpdated: 2026-09-10 +--- + +Zanim zaczniesz ćwiczenia Copilot CLI, przygotuj środowisko. W ramach tego ćwiczenia utworzysz własną kopię repozytorium Tailspin Toys i uruchomisz [codespace][codespaces], wewnątrz którego za pomocą zintegrowanego terminala zainstalujesz i uruchomisz Copilot CLI w następnym ćwiczeniu. + +## Skonfiguruj repozytorium + +Warsztaty będą prowadzone na własnej kopii projektu Tailspin Toys. Utwórz ją teraz za pomocą [repozytorium szablonu][template-repository]. Nowe repozytorium zawiera wszystkie pliki potrzebne w warsztatach — w kolejnych ćwiczeniach będziesz z niego korzystać. + +1. W nowym oknie przeglądarki przejdź do repozytorium tych warsztatów na GitHubie: `https://github.com/github-samples/tailspin-toys`. +2. Utwórz własną kopię repozytorium, wybierając przycisk **Use this template** na stronie repozytorium. Następnie wybierz **Create a new repository**. + + ![Przycisk Use this template z wybraną z listy rozwijanej opcją Create a new repository](../../_images/ex0-use-template.png) + +3. Jeśli uczestniczysz w warsztacie w ramach wydarzenia prowadzonego przez GitHuba lub Microsoft, postępuj zgodnie z instrukcjami mentorów. W przeciwnym razie możesz utworzyć nowe repozytorium w organizacji, w której masz dostęp do GitHub Copilot. + + ![Formularz Create a new repository z github-samples/tailspin-toys wybranym jako szablon](../../_images/ex0-repository-settings.png) + +4. Zanotuj ścieżkę utworzonego repozytorium (**organization-or-user-name/repository-name**) — będziesz się do niej odwoływać później w trakcie zadań. + +> [!NOTE] +> Gdy tworzysz repozytorium z szablonu, backlog zgłoszeń (issues) GitHub jest tworzony automatycznie. Będziesz pracować na tych zgłoszeniach przez cały warsztat — nie musisz nic zgłaszać samodzielnie. + +## Tworzenie codespace + +Wykorzystasz codespace do wykonania ćwiczeń w ramach tych warsztatów. + +[GitHub Codespaces][codespaces] to chmurowe środowisko deweloperskie, które pozwala pisać, uruchamiać i debugować kod bezpośrednio w przeglądarce. Zapewnia pełnoprawne IDE z obsługą wielu języków programowania, rozszerzeń i narzędzi. + +1. Przejdź do nowo utworzonego repozytorium. +2. Wybierz zielony przycisk **Code**. + + ![Przycisk Code](../../_images/ex0-code-button.png) + +3. Wybierz kartę **Codespaces**, a następnie przycisk **+**, aby utworzyć nowy Codespace. + + ![Tworzenie nowego codespace](../../_images/ex0-create-codespace.png) + +Utworzenie codespace zajmie kilka minut, choć i tak jest to znacznie szybsze niż ręczne instalowanie wszystkich bibliotek lokalnie. Możesz wykorzystać ten czas na poznanie innych funkcji GitHub Copilot, do których przejdziemy dalej. + +> [!CAUTION] +> Wrócisz do codespace w kolejnym ćwiczeniu. Na razie zostaw je otwarte w karcie przeglądarki. + +> [!NOTE] +> Ten warsztat jest przeznaczony do uruchamiania w codespace lub lokalnym [kontenerze deweloperskim][dev-containers]. Oba rozwiązania zapewniają środowisko ze wszystkimi wymaganymi zależnościami. Jeśli wolisz pracować lokalnie, otwórz sklonowane repozytorium w VS Code i wybierz **Reopen in Container**, gdy zostaniesz o to poproszony — VS Code zbuduje ten sam kontener deweloperski, którego używa codespace. + +## Podsumowanie + +Gratulacje — utworzyłeś własną kopię repozytorium Tailspin Toys! Rozpocząłeś też tworzenie codespace, z którego skorzystasz, gdy zaczniesz pracę z Copilot CLI. + +## Następny krok + +W następnym kroku zainstalujesz Copilot CLI i uwierzytelnisz się za pomocą konta GitHub. Przejdź do [Ćwiczenia 1 - Instalacja GitHub Copilot CLI][next-lesson]. + +## Zasoby + +- [Przegląd GitHub Codespaces][codespaces] +- [Tworzenie repozytorium z szablonu][template-repository] +- [Pierwsze kroki z Codespaces][codespaces-quickstart] + +[template-repository]: https://docs.github.com/repositories/creating-and-managing-repositories/creating-a-template-repository +[codespaces-quickstart]: https://docs.github.com/codespaces/getting-started/quickstart +[next-lesson]: ../1-install-copilot-cli/ +[codespaces]: https://github.com/features/codespaces +[dev-containers]: https://code.visualstudio.com/docs/devcontainers/containers diff --git a/docs/pl-pl/cli/1-install-copilot-cli.md b/docs/pl-pl/cli/1-install-copilot-cli.md new file mode 100644 index 00000000..32647e14 --- /dev/null +++ b/docs/pl-pl/cli/1-install-copilot-cli.md @@ -0,0 +1,130 @@ +--- +title: "Ćwiczenie 1 - Instalacja GitHub Copilot CLI" +authors: + - geektrainer + - azkel +lastUpdated: 2026-09-10 +--- + +[GitHub Copilot CLI][about-copilot-cli] to wielozadaniowy oparty na pracy agentów asystent programowania działający w terminalu. Pozwala eksplorować kod źródłowy, generować nowy, uruchamiać polecenia i korzystać z zewnętrznych narzędzi — wszystko za pomocą linii poleceń. Możesz zlecać zadania i prosić o zmiany, samemu skupiając się na zadaniach wysokiego poziomu. Pierwszy krok, jak można się spodziewać, to instalacja narzędzia! Na szczęście da się to zrobić za pomocą innych narzędzi, które już znasz. + +Podczas tego ćwiczenia: + +- zainstalujesz GitHub Copilot CLI za pomocą npm. +- uwierzytelnisz się kontem GitHuba. +- zweryfikujesz instalację. + +## Scenariusz + +Twój zespół zaczyna używać agentów AI do pracy nad rosnącym backlogiem. Copilot CLI przenosi tę możliwość do terminala, w którym wielu deweloperów i tak spędza czas. To ćwiczenie doprowadzi Cię do instalacji, uwierzytelnienia i gotowości do korzystania z narzędzia w dalszej części tych warsztatów. + +## Otwórz terminal w codespace + +Przed instalacją Copilot CLI otwórz okno terminala w codespace. + +1. Wróć do codespace, jeśli jeszcze go nie masz otwartego. +2. Otwórz okno terminala. Użyj kombinacji Ctrl+\`. +3. Na dole okna VS Code powinien pojawić się panel terminala. + +## Zainstaluj Copilot CLI + +Copilot CLI możesz zainstalować przez [npm][install-npm], [WinGet][install-winget] i [Homebrew][install-homebrew]. Ponieważ GitHub Codespaces mają wstępnie zainstalowany Node.js, użyjesz npm do instalacji Copilot CLI. + +1. W terminalu sprawdź, czy Node.js jest zainstalowany i spełnia wymaganie wersji: + + ```bash + node --version + ``` + + Powinieneś zobaczyć wersję 22 lub nowszą (np. `v22.x.x`). + +2. Zainstaluj Copilot CLI globalnie w codespace za pomocą npm: + + ```bash + npm install -g @github/copilot + ``` + +3. Zweryfikuj instalację, sprawdzając wersję: + + ```bash + copilot --version + ``` + + Powinieneś zobaczyć numer wersji (np. `v1.0.XX`). + +> [!TIP] +> Jeśli napotkasz błędy związane z uprawnieniami, na niektórych systemach może być potrzebne `sudo npm install -g @github/copilot`. W GitHub Codespaces zwykle nie jest to konieczne. + +## Uwierzytelnij się w GitHubie + +Przy pierwszym uruchomieniu Copilot CLI poprosi Cię o uwierzytelnienie kontem GitHuba. + +1. Uruchom Copilot CLI: + + ```bash + copilot + ``` + +2. Jeśli nie jesteś zalogowany, zobaczysz prośbę o uwierzytelnienie. Copilot CLI wyświetli kod urządzenia i poprosi o odwiedzenie adresu URL. +3. Postępuj zgodnie z instrukcjami na ekranie: + - Otwórz podany adres URL w przeglądarce + - Wprowadź kod urządzenia, gdy zostaniesz o to poproszony + - Autoryzuj Copilot CLI do dostępu do konta GitHuba +4. Po uwierzytelnieniu zobaczysz interfejs Copilot CLI, gotowy na pytania i polecenia. + +> [!NOTE] +> W codespace możesz być już uwierzytelniony przez sesję GitHuba. Jeśli Copilot CLI uruchomi się bez prośby o uwierzytelnienie, wszystko jest w porządku! + +## Zaufaj katalogowi i sprawdź, czy wszystko działa + +Skoro jesteś po raz pierwszy w interfejsie Copilot CLI, gdy wyświetli się stosowne powiadomienie, zaufaj temu repozytorium i upewnij się, że Copilot CLI jest poprawnie zainstalowany i połączony. + +1. Gdy Copilot CLI poprosi o potwierdzenie, że ufasz plikom w tym folderze, zobaczysz trzy opcje: + - **Yes, proceed**: Zaufaj tylko w tej sesji + - **Yes, and remember this folder for future sessions**: Zaufaj na stałe + - **No, exit (Esc)**: Nie zezwalaj na dostęp do plików +2. Na potrzeby tych warsztatów wybierz **Yes, and remember this folder for future sessions**, ponieważ będziesz pracować w tym repozytorium przez cały czas. +3. Zadaj Copilotowi proste pytanie, aby sprawdzić, czy działa: + + ``` + What files are in this project? + ``` + +4. Copilot zbada repozytorium i podsumuje strukturę projektu. +5. Wypróbuj polecenie `/help`, aby zobaczyć dostępne polecenia slash: + + ``` + /help + ``` + +6. Wyjdź z Copilot CLI, wprowadzając w terminalu poniższe polecenie. Wrócimy do Copilot CLI w kolejnym ćwiczeniu! + + ``` + exit + ``` + +## Podsumowanie i kolejne kroki + +Gratulacje! Pomyślnie zainstalowałeś i uwierzytelniłeś GitHub Copilot CLI. Nauczyłeś się: + +- instalować Copilot CLI za pomocą npm. +- uwierzytelniać się kontem GitHuba. +- ufać katalogowi, z którym ma pracować Copilot CLI. +- weryfikować, że instalacja działa poprawnie. + +W następnym kroku dasz Copilotowi kontekst projektu. Przejdź do [Ćwiczenia 2 - Instrukcje niestandardowe (Copilot CLI)][next-lesson]. + +## Zasoby + +- [Instalacja GitHub Copilot CLI][install-copilot-cli] +- [O Copilot CLI][about-copilot-cli] +- [Korzystanie z Copilot CLI][using-copilot-cli] + +[previous-lesson]: ../0-prerequisites/ +[next-lesson]: ../2-custom-instructions/ +[install-copilot-cli]: https://docs.github.com/copilot/how-tos/set-up/install-copilot-cli +[install-npm]: https://docs.github.com/copilot/how-tos/copilot-cli/set-up-copilot-cli/install-copilot-cli#installing-with-npm-all-platforms +[install-winget]: https://docs.github.com/copilot/how-tos/copilot-cli/set-up-copilot-cli/install-copilot-cli#installing-with-winget-windows +[install-homebrew]: https://docs.github.com/copilot/how-tos/copilot-cli/set-up-copilot-cli/install-copilot-cli#installing-with-homebrew-macos-and-linux +[about-copilot-cli]: https://docs.github.com/copilot/concepts/agents/about-copilot-cli +[using-copilot-cli]: https://docs.github.com/copilot/how-tos/use-copilot-agents/use-copilot-cli diff --git a/docs/pl-pl/cli/2-custom-instructions.md b/docs/pl-pl/cli/2-custom-instructions.md new file mode 100644 index 00000000..9006eddd --- /dev/null +++ b/docs/pl-pl/cli/2-custom-instructions.md @@ -0,0 +1,232 @@ +--- +title: "Ćwiczenie 2 - Instrukcje niestandardowe (Copilot CLI)" +authors: + - geektrainer + - azkel +lastUpdated: 2026-09-10 +--- + +[← Poprzednie ćwiczenie: Instalacja Copilot CLI][previous-lesson] · [Następne ćwiczenie: Generowanie kodu z CLI →][next-lesson] + +Kontekst jest kluczowy przy pracy z generatywną AI. Jeśli zadanie ma być wykonane w określony sposób — albo istnieje kontekst, który Copilot powinien znać — chcesz mieć pewność, że te informacje są dostępne dla agenta. Masz kilka narzędzi, które pomagają Copilotowi; poznamy je w trakcie tych warsztatów. Zaczynamy od [plików instrukcji][instruction-files], które zwykle skupiają się na tym, jak sam kod powinien być ustrukturyzowany. Dzięki temu Copilot rozumie nie tylko *jaki* kod chcesz, ale też *jak* powinien być zbudowany. + +Podczas tego ćwiczenia: + +- zobaczysz, jak kontekst projektu, wytyczne kodowania i standardy dokumentacji docierają do Copilota przez instrukcje niestandardowe repozytorium oraz pliki instrukcji ograniczone ścieżką, +- wygenerujesz pierwszy fragment kodu pod filtrowanie danych przy *obecnych* instrukcjach, +- dodasz nowy standard dla całego repozytorium do `.github/copilot-instructions.md`, +- uruchomisz polecenie uzupełniające i zobaczysz, jak zregenerowany kod przyjmie nowy standard, +- zatwierdzisz (commit) zmiany w instrukcjach i helperze, aby kolejne ćwiczenie mogło na nich budować. + +> [!CAUTION] +> Wygenerowany kod może odbiegać od części ustalonych standardów. Copilot jest niedeterministyczny. Celem jest zobaczenie *tendencji* zmiany zachowania po aktualizacji instrukcji, a nie dopasowanie wyniku znak po znaku. + +## Pliki instrukcji + +### Scenariusz + +Jak każdy dobry zespół deweloperski, Tailspin Toys ma zestaw wytycznych i wymagań dotyczących praktyk rozwoju. Obejmują one: + +- Warstwa danych zawsze wymaga testów jednostkowych. +- UI powinien być w trybie ciemnym i mieć nowoczesny wygląd. +- Dokumentacja powinna być dodawana do kodu w formie komentarzy TSDoc. +- Na początku każdego pliku powinien znaleźć się blok komentarzy opisujący, co plik robi. + +Dzięki plikom instrukcji zapewnisz Copilotowi właściwe informacje, aby wykonywał zadania zgodnie z tymi praktykami. + +### Instrukcje niestandardowe + +Instrukcje niestandardowe pozwalają przekazać Copilotowi kontekst i preferencje, żeby lepiej rozumiał styl programowania i oczekiwania. To potężna funkcja, która pomaga kierować Copilota ku bardziej trafnym sugestiom i fragmentom kodu. Możesz określić preferowane konwencje pisania kodu, wykorzystywanych bibliotek, a nawet typy komentarzy, które lubisz w kodzie. Instrukcje możesz tworzyć dla całego repozytorium albo dla konkretnych typów plików — z kontekstem na poziomie zadania. + +Są dwa typy plików instrukcji: + +- `.github/copilot-instructions.md` — jeden plik instrukcji wysyłany do Copilota przy **każdym** żądaniu dla repozytorium. Powinien zawierać informacje na poziomie projektu — kontekst istotny dla większości żądań czatu lub CLI do Copilota. Może to być używany stack technologiczny, przegląd tego, co budujesz, dobre praktyki i inne globalne wskazówki. +- Pliki `.github/instructions/*.instructions.md` można tworzyć dla konkretnych zadań lub typów plików. Użyjesz ich do wytycznych dla określonych języków (np. TypeScript lub Astro) albo zadań takich jak tworzenie komponentu UI czy nowego zestawu testów jednostkowych. + +> [!NOTE] +> W IDE pliki instrukcji są używane tylko do generowania kodu w Copilot Chat — nie do uzupełnień kodu ani sugestii następnej edycji. +> +> Copilot Chat, Copilot CLI i Copilot cloud agent korzystają zarówno z plików na poziomie repozytorium, jak i z plików `*.instructions.md` (z front matter `applyTo`) przy generowaniu kodu. +> +> Ponadto Copilot [obsługuje pliki instrukcji według innych standardów][custom-instructions-support], w tym AGENTS.md i CLAUDE.md. + +### Dobre praktyki zarządzania plikami instrukcji + +Zaawansowane metodologie tworzenia plików instrukcji wykraczają poza zakres warsztatu. Przykłady w tym projekcie pokazują jednak reprezentatywne podejście. Na wysokim poziomie: + +- W `copilot-instructions.md` trzymaj wskazówki na poziomie projektu: opis tego, co budujesz, strukturę projektu i globalne standardy kodowania. +- Używaj plików `*.instructions.md` do konkretnych instrukcji dla typów plików (testy jednostkowe, komponenty Astro, warstwa danych) lub zadań. +- Pisz językiem naturalnym. Utrzymuj wskazówki jasne. Podawaj przykłady, jak kod powinien (i nie powinien) wyglądać. + +Nie ma jednej właściwej metody tworzenia plików instrukcji — tak jak nie ma jednej właściwej metody używania AI. Eksperymentując, znajdziesz to, co najlepiej działa w Twoim projekcie. + +> [!TIP] +> Każdy projekt korzystający z GitHub Copilot powinien mieć solidny zestaw plików instrukcji. Przeglądając te w tym projekcie, możesz zauważyć pliki dla wielu typów zadań, w tym [aktualizacji UI][ui-instructions] i [Astro][astro-instructions]. +> +> Copilot może też pomóc wygenerować pliki instrukcji. Każde środowisko robi to inaczej (np. **Configure Chat → Generate Agent Instructions** w VS Code albo `/init` w Copilot CLI) — ćwiczenie dla środowiska, w którym jesteś, wskaże to, gdy będzie to istotne. +> +> Szukasz szablonów lub punktu startowego? Zobacz [awesome-copilot][awesome-copilot] — repozytorium pełne plików instrukcji, agentów niestandardowych i innych zasobów. + +## Przegląd plików instrukcji niestandardowych w tym projekcie + +Poświęć chwilę na przeczytanie plików instrukcji dostarczonych z tym repozytorium — jest jeden główny `copilot-instructions.md` oraz kolekcja plików `*.instructions.md` dla różnych zadań. Otwórz je w edytorze lub w interfejsie webowym GitHuba. + +1. Otwórz `.github/copilot-instructions.md`. +2. Przejrzyj plik, zwracając uwagę na krótki opis projektu oraz sekcje takie jak **Agent notes**, **Code standards**, **Scripts** i **Repository Structure**. W **Code standards** zwróć uwagę na zagnieżdżone wskazówki **GitHub Actions Workflows**. Dotyczą one każdej interakcji z Copilotem. +3. Otwórz folder `.github/instructions` i przejrzyj dostępne pliki. Są instrukcje dla plików Astro, warstwy danych Drizzle, testów i innych. +4. Otwórz `.github/instructions/unit-tests.instructions.md`. Zwróć uwagę na pole `applyTo` na górze — ustawia glob (względem katalogu głównego repozytorium), który określa, do których plików instrukcje się stosują. Tutaj pasuje każdy plik testów TypeScript (np. zgodny ze ścieżką `**/*.test.ts`). +5. Zwróć uwagę na instrukcje dotyczące tworzenia testów jednostkowych w tym projekcie. +6. Na koniec otwórz `.github/instructions/drizzle.instructions.md` i przewiń na dół. Zwróć uwagę na odnośniki do innych plików instrukcji (np. `unit-tests.instructions.md`) oraz istniejących plików w projekcie. Dzięki temu możesz dzielić większe zestawy instrukcji na mniejsze pliki wielokrotnego użytku i wskazywać Copilotowi przykłady do naśladowania przy generowaniu kodu. (Ścieżki tam są względne w odniesieniu do pliku instrukcji, a nie katalogu głównego repozytorium.) + +> [!NOTE] +> Sekcja **Code formatting requirements** w `copilot-instructions.md` dokumentuje standardy pisania kodu w projekcie, ale jeszcze nie wymaga dokumentacji w kodzie. W kolejnych krokach dodasz reguły dla komentarzy TSDoc i nagłówków komentarzy plików. + +## Utwórz gałąź + +Będziesz wprowadzać zmiany w kodzie, więc utwórz gałąź do pracy. + +1. W terminalu codespace utwórz i przełącz się na nową gałąź: + + ```bash + git checkout -b update-custom-instructions + ``` + +2. Upewnij się, że Copilot CLI jest zainstalowany i uwierzytelniony: + + ```bash + copilot --version + ``` + + Jeśli polecenie nie zostanie znalezione lub nie jesteś zalogowany, wróć do [Ćwiczenia 1 - Instalacja GitHub Copilot CLI](../1-install-copilot-cli/). + +## Użyj Copilot CLI *przed* aktualizacją instrukcji + +Aby zobaczyć wpływ instrukcji niestandardowych, zacznij od wygenerowania kodu przy obecnych instrukcjach. Później zaktualizujesz plik i uruchomisz polecenie uzupełniające. + +> [!CAUTION] +> `--yolo` włącza pełne automatyczne uprawnienia (`--allow-all-tools`, `--allow-all-paths` i `--allow-all-urls`). Używaj go tylko w izolowanym środowisku, takim jak codespace lub maszyna wirtualna, i nigdy nie ustawiaj go jako domyślnego aliasu w codziennej pracy. Szczegóły: [Allowing and denying tool use][allow-all-warning]. + +Uruchomienie Copilot CLI z **katalogu głównego repozytorium** zapewnia automatyczne wczytanie `.github/copilot-instructions.md`. `--enable-all-github-mcp-tools` włącza narzędzia GitHub MCP do odczytu/zapisu, aby Copilot mógł czytać backlog i otwierać pull requesty w dalszej części tych warsztatów. + +1. Wróć do codespace. Jeśli go zamknąłeś, przejdź do repozytorium na GitHub.com, wybierz **Code** > **Codespaces**, a następnie ponownie otwórz istniejący codespace. +2. Wróć do otwartej sesji Copilot CLI. Jeśli terminal jest zamknięty lub wyszedłeś z Copilot CLI, otwórz terminal. Użyj kombinacji Ctrl+\`, a następnie uruchom go z katalogu głównego repozytorium poleceniem `copilot --yolo --enable-all-github-mcp-tools`. Zaufaj folderowi projektu, jeśli zostaniesz o to poproszony, potem uruchom `/models` i wybierz **Auto**. +3. W interfejsie Copilot CLI poproś o wygenerowanie funkcji wspomagającej filtrowanie danych o dostępnych wydawcach: + + ```plaintext + Create a new data-access helper at src/lib/publishers.ts to return a list of all publishers. It should return the name and id for all publishers. Do not run the tests yet. + ``` + +4. Copilot CLI zbada projekt, zaproponuje plan i zapisze plik w tej sesji `--yolo`. Monitoruj zmiany w oknie terminala, a następnie przejrzyj je w edytorze. +5. Otwórz wygenerowany `src/lib/publishers.ts` w edytorze. +6. Zwróć uwagę, że funkcja wspomagająca to typowana metoda przyjmująca klienta `db` jako pierwszy argument i zwracająca typowaną tablicę wydawców — to wynika z konwencji warstwy danych w `.github/instructions/drizzle.instructions.md` (które dotyczą `src/lib/*.ts`). +7. Zwróć uwagę, że w wygenerowanym kodzie **brakuje** komentarzy TSDoc oraz nagłówka komentarza na poziomie pliku. + +> [!CAUTION] +> Copilot jest probabilistyczny — istnieje szansa, że doda komentarze dokumentacyjne nawet bez polecenia. Jeśli tak się stanie, to w porządku; wnioskiem nadal jest *poprawa spójności* po aktualizacji instrukcji. + +## Dodaj nowy standard repozytorium + +Jak wspomniano wcześniej, `.github/copilot-instructions.md` służy do przekazywania Copilotowi informacji na poziomie projektu. Upewnijmy się, że standardy kodowania repozytorium są udokumentowane, aby poprawić sugestie kodu. + +1. Ponownie otwórz `.github/copilot-instructions.md`. +2. Znajdź sekcję **Code formatting requirements**, która powinna być w okolicy linii 27. Zwróć uwagę, jak dokumentuje standardy samego pisania kodu w projekcie — ale nie ma jeszcze reguły odnośnie pisania dokumentacji w kodzie, dlatego wygenerowany helper nie miał adekwatnej dokumentacji w postaci komentarzy. +3. Dodaj poniższe linie markdown tuż pod istniejącymi standardami, aby poinstruować Copilota o nagłówkach z komentarzami w plikach i komentarzach TSDoc: + + ```markdown + - Every exported function should have a TSDoc comment describing its purpose, parameters, and return value. + - Before imports or any code, add a comment block to the file that explains its purpose. + ``` + +4. Zapisz `copilot-instructions.md`. + +> [!TIP] +> Jak widziałeś w poprzednim ćwiczeniu, pliki instrukcji można tworzyć na poziomie repozytorium (`.github/copilot-instructions.md`) dla wskazówek globalnych albo jako pliki `*.instructions.md` dla konkretnych języków, typów plików lub zadań. Plik na poziomie repozytorium to właściwe miejsce na standardy obejmujące cały projekt, takie jak reguła komentarzy dokumentacyjnych, którą właśnie dodałeś. + +## Ponownie uruchom polecenie i zaobserwuj zmianę + +Skoro instrukcje mają już wpis o generowaniu komentarzy, poproś Copilot CLI o aktualizację właśnie wygenerowanego pliku wydawców. Ta sama dyrektywa standardów pokieruje przepisaniem. + +1. Wyślij `/clear` w sesji Copilot CLI, aby zacząć od czystej rozmowy. +2. Wyślij poniższe polecenie: + + ```plaintext + Update src/lib/publishers.ts to follow the latest documentation conventions in .github/copilot-instructions.md. + ``` + +3. Poczekaj na zakończenie edycji, a następnie ponownie otwórz `src/lib/publishers.ts`. +4. Zwróć uwagę, że plik otwiera się teraz blokiem komentarza podobnym do: + + ```typescript + /** + * Publisher data-access helpers for the Tailspin Toys Crowd Funding platform. + * Provides functions to retrieve publisher information from the database. + */ + ``` + +5. Zwróć uwagę, że wygenerowana funkcja zawiera teraz komentarz TSDoc podobny do: + + ```typescript + /** + * Returns a list of all publishers with their id and name. + * + * @param db - The Drizzle database client. + * @returns A promise that resolves to an array of publisher objects. + */ + ``` + +6. Zostaw ten zaktualizowany plik na miejscu. To pierwszy fragment danych, na którym zbudujesz kolejne funkcjonalności w następnym ćwiczeniu. + +## Commit i push pierwszego fragmentu filtrowania + +1. W terminalu sprawdź zmienione pliki: + + ```bash + git status + ``` + +2. Dodaj do listy zmian aktualizację instrukcji i zmodyfikowany kod: + + ```bash + git add .github/copilot-instructions.md src/lib/publishers.ts + ``` + +3. Zatwierdź zmiany: + + ```bash + git commit -m "Add doc comment standards and publishers helper foundation" + ``` + +4. Wypchnij gałąź: + + ```bash + git push -u origin update-custom-instructions + ``` + +## Podsumowanie i kolejne kroki + +Zobaczyłeś, jak Copilot pobiera kontekst z plików instrukcji w tym projekcie, a następnie użyłeś Copilot CLI do: + +- wygenerowania fundamentu funkcji wspomagającej filtrowanie danych wydawców za pomocą *istniejących* instrukcji, +- dodania nowego standardu dla całego repozytorium w `.github/copilot-instructions.md`, +- uruchomienia polecenia aktualizującego poprzednie instrukcje i obserwacji, jak zregenerowany kod przyjął nowy standard, +- zatwierdzenia i wypchnięcia zarówno zmian w instrukcjach, jak i pierwszych zmian w kodzie. + +W następnym kroku zastosujesz te instrukcje, realizując pracę z backlogu w [ćwiczeniu generowania kodu][next-lesson]. + +## Zasoby + +- [Pliki instrukcji do dostosowywania GitHub Copilot][instruction-files] +- [Dobre praktyki tworzenia instrukcji niestandardowych][instructions-best-practices] +- [5 wskazówek dotyczących lepszych instrukcji niestandardowych dla Copilot][copilot-instructions-five-tips] +- [Awesome Copilot — zbiór plików instrukcji i innych zasobów][awesome-copilot] + +[previous-lesson]: ../1-install-copilot-cli/ +[next-lesson]: ../3-generating-code/ +[instruction-files]: https://docs.github.com/copilot/customizing-copilot/about-customizing-github-copilot-chat-responses +[instructions-best-practices]: https://docs.github.com/enterprise-cloud@latest/copilot/using-github-copilot/coding-agent/best-practices-for-using-copilot-to-work-on-tasks#adding-custom-instructions-to-your-repository +[copilot-instructions-five-tips]: https://github.blog/ai-and-ml/github-copilot/5-tips-for-writing-better-custom-instructions-for-copilot/ +[allow-all-warning]: https://docs.github.com/copilot/how-tos/copilot-cli/use-copilot-cli/allowing-tools +[ui-instructions]: https://github.com/github-samples/tailspin-toys/blob/main/.github/instructions/ui.instructions.md +[astro-instructions]: https://github.com/github-samples/tailspin-toys/blob/main/.github/instructions/astro.instructions.md +[awesome-copilot]: https://github.com/github/awesome-copilot +[custom-instructions-support]: https://docs.github.com/copilot/reference/custom-instructions-support diff --git a/docs/pl-pl/cli/3-generating-code.md b/docs/pl-pl/cli/3-generating-code.md new file mode 100644 index 00000000..e5d342cb --- /dev/null +++ b/docs/pl-pl/cli/3-generating-code.md @@ -0,0 +1,84 @@ +--- +title: "Ćwiczenie 3 - Dodawanie nowych funkcji z GitHub Copilot CLI" +authors: + - geektrainer + - azkel +lastUpdated: 2026-09-10 +--- + +Jak można się spodziewać, podstawowe zadania, które możesz wykonać za pomocą GitHub Copilot CLI, to dodawanie nowych funkcji i kodu do projektu. Weźmy jedno ze zgłoszeń z backlogu i poprośmy Copilota o pomoc w implementacji. + +## Scenariusz + +Nadszedł czas, aby dokończyć implementację filtrowania w projekcie. Masz już zgłoszenie o filtrowaniu w backlogu oraz fundament helpera z poprzedniego ćwiczenia. Niech Copilot pobierze szczegóły zgłoszenia, uwzględni istniejącą pracę i zbuduje pozostałą funkcjonalność. + +Podczas tego ćwiczenia: + +- użyjesz trybu planowania do wygenerowania planu implementacji filtrowania. +- wygenerujesz kod potrzebny do dodania filtrowania do witryny, wykorzystując Copilota. + +Po zakończeniu tego ćwiczenia dodasz nową funkcjonalność do projektu. + +## Użyj trybu planowania + +Jednym z najlepszych zastosowań AI jest planowanie. Często masz dobrą koncepcję tego, co chcesz zbudować, ale chciałbyś z kimś przedyskutować swoje pomysły. Narzędzia AI pomagają skrystalizować myśli, zadając pytania uzupełniające i przechodząc przez pułapki lub brakujące elementy. Copilot CLI oferuje tryb planowania. Czas spędzony na planowaniu pomoże też Copilotowi wygenerować kod lepiej dopasowany do wymagań. + +Zacznijmy tworzenie nowej funkcjonalności od trybu planowania w Copilot CLI. + +1. Wróć do codespace. Jeśli go zamknąłeś, przejdź do repozytorium na GitHub.com, wybierz **Code** > **Codespaces**, a następnie ponownie otwórz istniejący codespace. +2. Wróć do otwartej sesji Copilot CLI. Jeśli terminal jest zamknięty lub wyszedłeś z Copilot CLI, otwórz terminal. Użyj kombinacji Ctrl+\`, a następnie uruchom go z katalogu głównego repozytorium poleceniem `copilot --yolo --enable-all-github-mcp-tools`. Zaufaj folderowi projektu, jeśli zostaniesz o to poproszony, potem uruchom `/models` i wybierz **Auto**. +3. Użyj poniższego polecenia w Copilot CLI, aby utworzyć plan na podstawie zgłoszenia o filtrowaniu: + + ``` + /plan Retrieve the issue on the repository related to adding filtering. We already added a publishers helper in src/lib/publishers.ts, so treat that as existing work and plan the remaining updates (games filtering logic, UI, and tests). + ``` + +4. Copilot może zadawać pytania uzupełniające podczas budowania planu. Odpowiadaj na nie zgodnie z tym, jak zbudowałbyś funkcjonalność. +5. Gdy plan zostanie wygenerowany, przejrzyj go. Powinieneś zauważyć rekomendacje pozostałych zmian w warstwie danych i UI oraz generowanie testów. +6. Copilot CLI pozwoli Ci przekazać dodatkową opinię do planu. Możesz przejść kursorem w dół do wskazanej sekcji i wpisać sugestie. Copilot uwzględni je w nowej wersji planu. +7. Gdy będziesz zadowolony, wybierz opcję oferowaną przez Copilota, aby rozpocząć budowanie nowej funkcji! + +> [!NOTE] +> Ponieważ Copilot jest probabilistyczny, dokładny tekst i opcje będą się różnić. Powinieneś zobaczyć opcję rozpoczęcia budowania podobną do: +> +> `Yes, and switch to autopilot mode`. +> +> Copilot może zaproponować włączenie [trybu autopilot](https://docs.github.com/copilot/concepts/agents/copilot-cli/autopilot), jak w przykładzie powyżej. Tryb autopilot pozwala Copilot CLI pracować nad zadaniem bez czekania na Twoje dane wejściowe po każdym kroku. Po początkowej instrukcji Copilot CLI przechodzi przez kolejne kroki autonomicznie, aż uzna zadanie za ukończone. Ponieważ działamy w izolowanym środowisku, możemy uruchomić autopilot i zezwolić na wszystkie narzędzia. + +8. Copilot zabierze się do generowania plików! + +> [!NOTE] +> Ta operacja prawdopodobnie zajmie kilka minut. Zobaczysz, jak Copilot edytuje i tworzy pliki, aktualizuje i generuje testy oraz uruchamia wszystkie testy, aby upewnić się, że wszystko przechodzi. To dobry moment, by zastanowić się nad tym, co już poznałeś na warsztatach, albo napić się czegoś. + +## Przejrzyj kod + +Każdy kod AI należy przejrzeć przed scaleniem do głównej gałęzi. Poświęćmy teraz czas na przejrzenie plików utworzonych i zmodyfikowanych przez Copilota przy implementacji nowej funkcji. + +1. Użyj Copilot CLI, aby wyświetlić „diff” lub zmiany w kodzie, wpisując w Copilot CLI: + + ``` + /diff + ``` + +2. Zwróć uwagę na zmienione pliki. Użyj klawiszy strzałek w lewo i w prawo, aby przeglądać różne pliki. Powinieneś zobaczyć zmiany m.in. na stronie listy gier (gdzie wyświetlamy nowe elementy interfejsu sterujące filtrem i filtrowanie po stronie klienta) oraz w `src/lib/games.ts`, a także testy takie jak `games.test.ts`. Możesz też zobaczyć zmiany w `publishers.ts`, jeśli Copilot dopracuje istniejący helper pod pełną implementację. + +## Podsumowanie i kolejne kroki + +Dodałeś filtrowanie do witryny za pomocą Copilot CLI! Konkretnie: + +- użyłeś trybu planowania do wygenerowania planu implementacji filtrowania. +- wygenerowałeś kod potrzebny do dodania filtrowania do witryny, wykorzystując Copilota. + +W następnym kroku sprawdzisz, czy działa. [Przetestujmy funkcję serwerem Playwright MCP][next-lesson], zanim otworzysz pull request. + +## Zasoby + +- [Korzystanie z Copilot CLI][using-copilot-cli] +- [O Copilot CLI][about-copilot-cli] +- [Zarządzanie kontekstem w Copilot CLI][context-management] + +[previous-lesson]: ../2-custom-instructions/ +[next-lesson]: ../4-mcp/ +[using-copilot-cli]: https://docs.github.com/copilot/how-tos/use-copilot-agents/use-copilot-cli +[about-copilot-cli]: https://docs.github.com/copilot/concepts/agents/about-copilot-cli +[context-management]: https://docs.github.com/copilot/how-tos/use-copilot-agents/use-copilot-cli#context-management diff --git a/docs/pl-pl/cli/4-mcp.md b/docs/pl-pl/cli/4-mcp.md new file mode 100644 index 00000000..da778e4c --- /dev/null +++ b/docs/pl-pl/cli/4-mcp.md @@ -0,0 +1,144 @@ +--- +title: "Ćwiczenie 4 - Testowanie funkcji serwerem Playwright MCP" +authors: + - geektrainer + - azkel +lastUpdated: 2026-09-10 +--- + +Właśnie wygenerowałeś funkcję filtrowania wykorzystując Copilot CLI. Zanim otworzysz pull request, upewnij się, że działa w przeglądarce. Zamiast klikać po aplikacji samodzielnie, połączysz **serwer Playwright MCP** i pozwolisz Copilotowi sterować prawdziwą przeglądarką, aby przetestować funkcję za Ciebie. + +Podczas tego ćwiczenia: + +- zrozumiesz, czym jest Model Context Protocol (MCP) i jak serwery MCP rozszerzają Copilot CLI. +- dodasz serwer Playwright MCP do Copilot CLI. +- poprosisz Copilota, by użył go do ręcznego przetestowania funkcji filtrowania w przeglądarce. + +## Czym jest Model Context Protocol (MCP)? + +[Model Context Protocol (MCP)](https://github.blog/ai-and-ml/llms/what-the-heck-is-mcp-and-why-is-everyone-talking-about-it/) daje agentom AI sposób komunikacji z zewnętrznymi narzędziami i usługami. Dzięki MCP agenci AI mogą komunikować się z nimi w czasie rzeczywistym. Pozwala to uzyskiwać aktualne informacje (za pomocą zasobów) i wykonywać działania w Twoim imieniu (za pomocą narzędzi). + +Te narzędzia i zasoby są dostępne przez serwer MCP, który działa jako most między agentem AI a zewnętrznymi narzędziami i usługami. Serwer MCP zarządza komunikacją między agentem AI a narzędziami zewnętrznymi (np. istniejącymi API lub lokalnymi narzędziami, takimi jak pakiety NPM). Każdy serwer MCP reprezentuje inny zestaw narzędzi i zasobów dostępnych dla agenta AI. + +Kilka popularnych istniejących serwerów MCP: + +- **[GitHub MCP Server](https://github.com/github/github-mcp-server)**: Ten serwer zapewnia dostęp do zestawu API do zarządzania repozytoriami GitHub. Pozwala agentowi AI m.in. tworzyć nowe repozytoria, aktualizować istniejące oraz zarządzać zgłoszeniami i pull requestami. +- **[Playwright MCP Server](https://github.com/microsoft/playwright-mcp)**: Ten serwer zapewnia automatyzację przeglądarki za pomocą Playwright. Pozwala agentowi AI m.in. nawigować do stron, wypełniać formularze i klikać przyciski. + +Dostępnych jest wiele innych serwerów MCP z dostępem do różnych narzędzi i zasobów. GitHub hostuje [rejestr MCP](https://github.com/mcp), aby ułatwić odkrywanie i wkład w ekosystem. + +> [!CAUTION] +> Pod względem bezpieczeństwa traktuj serwery MCP jak każdą inną zależność w projekcie. Przed użyciem serwera MCP dokładnie przejrzyj jego kod źródłowy, zweryfikuj wydawcę i rozważ konsekwencje bezpieczeństwa. Używaj tylko zaufanych serwerów MCP i ostrożnie przyznawaj dostęp do wrażliwych zasobów lub operacji. + +> [!NOTE] +> [Serwer GitHub MCP][github-mcp-server] jest **wbudowany** w Copilot CLI — jest już dostępny bez konfiguracji, dzięki czemu Copilot czytał i zapisywał w Twoim repozytorium przez cały warsztat. Podczas tego ćwiczenia dodasz *drugi* serwer, Playwright, aby dać Copilotowi przeglądarkę. + +## Dodaj serwer Playwright MCP + +Najszybszym sposobem dodania serwera jest interaktywne polecenie `/mcp add`. Zarejestrujesz [serwer Playwright MCP][playwright-mcp-server], który da Copilotowi przeglądarkę, którą może sterować. + +1. Wróć do codespace. Jeśli go zamknąłeś, przejdź do repozytorium na GitHub.com, wybierz **Code** > **Codespaces**, a następnie ponownie otwórz istniejący codespace. +2. Wróć do otwartej sesji Copilot CLI. Jeśli terminal jest zamknięty lub wyszedłeś z Copilot CLI, otwórz terminal. Użyj kombinacji Ctrl+\`, a następnie uruchom go z katalogu głównego repozytorium poleceniem `copilot --yolo --enable-all-github-mcp-tools`. Zaufaj folderowi projektu, jeśli zostaniesz o to poproszony, potem uruchom `/models` i wybierz **Auto**. +3. W sesji Copilot CLI wpisz: + + ```text + /mcp add + ``` + +4. Pojawi się formularz konfiguracji. Użyj Tab, aby przechodzić między polami, i wypełnij je tak: + + - **Server Name**: `playwright` + - **Server Type**: wybierz **Local** (oznaczony też jako **STDIO**) + - **Command**: `npx @playwright/mcp@latest --headless` + - **Tools**: zostaw `*`, aby zezwolić na wszystkie narzędzia serwera + +5. Użyj kombinacji Ctrl+S, aby zapisać. Serwer jest dodany i od razu dostępny — restart nie jest wymagany. + +Flaga `--headless` każe Playwrightowi uruchamiać przeglądarkę bez widocznego okna, co jest wymagane w codespace, gdzie nie ma pulpitu do wyświetlenia. W tle zapisuje to serwer w pliku `~/.copilot/mcp-config.json`: + +```json +{ + "mcpServers": { + "playwright": { + "type": "local", + "command": "npx", + "args": ["@playwright/mcp@latest", "--headless"], + "tools": ["*"] + } + } +} +``` + +6. Upewnij się, że serwer jest zarejestrowany i aktywny, listując serwery MCP: + + ```text + /mcp show + ``` + +7. Powinieneś zobaczyć `playwright` na liście obok wbudowanego serwera `github`. + +> [!NOTE] +> Projekt Tailspin Toys już używa Playwrighta do testów end-to-end, więc przeglądarka potrzebna Playwrightowi jest zwykle już zainstalowana. Jeśli Copilot później zgłosi brak przeglądarki, każ mu uruchomić `npx playwright install chromium` i spróbuj ponownie. + +## Uruchom witrynę + +Serwer Playwright MCP potrzebuje działającej aplikacji do testów. Uruchom serwer deweloperski Astro w **osobnym** terminalu, żeby działał dalej, gdy pracujesz w Copilot CLI. + +1. Otwórz nowy terminal w codespace. Użyj kombinacji Ctrl+\`. +2. Uruchom witrynę: + + ```bash + npm run dev + ``` + +3. Zostaw ten terminal uruchomiony. Gdy zobaczysz baner `Astro server: http://localhost:4321`, aplikacja jest gotowa. + +## Przetestuj funkcję filtrowania + +Wróć do sesji Copilot CLI i poproś Copilota o przetestowanie funkcji. + +[Serwer Playwright MCP][playwright-mcp-server] daje Copilotowi prawdziwą przeglądarkę do sterowania. Zamiast klikać po aplikacji, by sprawdzić pracę, agent może otworzyć stronę, nawigować, zastosować filtry i odczytać wynik — a potem podsumować, co zobaczył. To najszybszy sposób upewnienia się, że funkcja zachowuje się zgodnie z oczekiwaniami, bez opuszczania rozmowy. + +Pod spodem serwer Playwright MCP działa na [drzewie dostępności][playwright-mcp-server] strony, a nie na zrzutach ekranu. Agent rozumuje więc nad ustrukturyzowanymi, oznaczonymi etykietami elementami (przyciski, linki, elementy list) tak samo jak technologie asystujące — szybki test funkcjonalny jest jednocześnie lekką kontrolą dostępności. + +Przy podłączonym serwerze i działającej aplikacji poproś Copilota o przećwiczenie właśnie zbudowanej funkcji filtrowania: + +```text +Using the Playwright MCP server, open a browser to the running app at http://localhost:4321 and verify the new game filtering feature: + +1. Go to the games page and note how many games are listed. +2. Apply a category filter and confirm the list updates to only show games in that category. +3. Clear it, then apply a publisher filter and confirm the list updates to that publisher. +4. Combine a category and a publisher filter and confirm the results respect both. + +Report what you observe at each step, and call out anything that does not behave as expected. +``` + +Copilot uruchomi przeglądarkę przez serwer Playwright MCP, przejdzie przez każdy krok i zgłosi, co znalazł. Porównaj jego podsumowanie z kryteriami akceptacji w zgłoszeniu — jeśli coś wygląda nie tak, zadaj pytania uzupełniające lub wyślij go z powrotem, by naprawił kod, zanim otworzysz pull request. + +> [!NOTE] +> Aplikacja musi działać pod adresem `http://localhost:4321` na potrzeby tego testu. Jeśli zatrzymałeś serwer deweloperski, uruchom go ponownie przed wysłaniem polecenia. Przy pierwszym użyciu serwera Playwright MCP Copilot może potrzebować pobrać przeglądarkę — jeśli zgłosi brak przeglądarki, każ mu uruchomić `npx playwright install chromium` i spróbuj ponownie. + +## Podsumowanie i kolejne kroki + +Gratulacje — użyłeś serwera Playwright MCP do ręcznego przetestowania funkcji za pomocą Copilot CLI! Podsumowując: + +- poznałeś Model Context Protocol (MCP) i to, jak serwery MCP rozszerzają Copilot CLI. +- dodałeś serwer Playwright MCP za pomocą `/mcp add`. +- poprosiłeś Copilota o sterowanie przeglądarką i weryfikację funkcji filtrowania przed wysyłką. + +W następnym kroku [otworzysz pull request za pomocą skillu agenta][next-lesson]. + +## Zasoby + +- [What the heck is MCP and why is everyone talking about it?][mcp-blog-post] +- [Microsoft Playwright MCP Server][playwright-mcp-server] +- [Dodawanie serwerów MCP do Copilot CLI][cli-add-mcp] +- [GitHub MCP Server][github-mcp-server] + +[previous-lesson]: ../3-generating-code/ +[next-lesson]: ../5-agent-skills/ +[mcp-blog-post]: https://github.blog/ai-and-ml/llms/what-the-heck-is-mcp-and-why-is-everyone-talking-about-it/ +[github-mcp-server]: https://github.com/github/github-mcp-server +[cli-add-mcp]: https://docs.github.com/copilot/how-tos/copilot-cli/customize-copilot/add-mcp-servers +[playwright-mcp-server]: https://github.com/microsoft/playwright-mcp diff --git a/docs/pl-pl/cli/5-agent-skills.md b/docs/pl-pl/cli/5-agent-skills.md new file mode 100644 index 00000000..94ea20fe --- /dev/null +++ b/docs/pl-pl/cli/5-agent-skills.md @@ -0,0 +1,106 @@ +--- +title: "Ćwiczenie 5 - Korzystanie ze skilli agenta" +authors: + - geektrainer + - azkel +lastUpdated: 2026-09-10 +--- + +Tworzenie aplikacji często obejmuje powtarzalne zadania, takie jak generowanie buildów, uruchamianie testów czy tworzenie pull requestów (PR). **Skille agenta (agent skills)** pozwalają przekazać Copilotowi — i innym agentom AI — wskazówki, jak wykonywać te zadania. Skill to folder z instrukcjami, skryptami i zasobami, które agent może wczytać na żądanie. [Agent Skills to otwarty standard][agent-skills-repo] używany przez różne agenty, więc ten sam skill może działać w Copilot Chat w trybie agenta, agentach Copilot w chmurze, Copilot CLI oraz aplikacji GitHub Copilot. + +Zobaczmy, jak skill może zapewnić, że pull requesty spełniają wymagania zespołu. + +## Scenariusz + +Zespół ma zestaw wymagań dla pull requestów: + +- jasne komunikaty commitów, z plikami pogrupowanymi logicznie. +- wszystkie testy muszą przejść przed utworzeniem PR. +- każdy PR musi zawierać następujące sekcje: + - opis, dlaczego wprowadzono zmiany. + - przegląd zmienionych plików. + - fragmenty ważnych bloków kodu. + - szczegóły zmian pogrupowane razem. + +Ponieważ zespół używa Copilota do generowania kodu i PR-ów, chce mieć pewność, że narzędzia AI przestrzegają tych wymagań. + +Podczas tego ćwiczenia: + +- przejrzysz istniejący skill do tworzenia pull requestów. +- nauczysz się, jak skille są wykorzystywane przez agenta AI. +- utworzysz PR zgodny z wytycznymi za pomocą skillu. + +## Tworzenie skilli agenta + +Skille znajdują się w folderze `.github/skills` projektu albo globalnie w `~/.copilot/skills`. Każdy skill to folder zawierający plik `SKILL.md` z nagłówkiem YAML (pola `name` i `description`), a następnie instrukcje w markdown: + +```yaml +--- +name: make-contribution +description: All changes to code must follow the guidance documented in the repository. Before any issue is filed, branch is made, commits generated, or pull request (or PR) created, a search must be done to ensure the right steps are followed. Whenever asked to create an issue, commit messages, to push code, or create a PR, use this skill so everything is done correctly. +--- +``` + +Skille mogą też zawierać podfoldery ze skryptami, zasobami i materiałami referencyjnymi. Pełna struktura jest opisana w [specyfikacji agent skills][agent-skills-spec]. + +> [!TIP] +> Skille są wczytywane dynamicznie. Agent decyduje, który skill ma zastosowanie, na podstawie pola `description` — jasny, związany ze scenariuszem opis to różnica między skillem, który zostanie użyty, a takim, który zostanie zignorowany. + +## Wykonywanie skilli + +Skille są wczytywane dynamicznie, gdy agent uzna, że są potrzebne. Decyzja, których skilli użyć, wynika z opisu w pliku `SKILL.md`. Dlatego ważne są jasne opisy definiujące przypadek użycia, który ma zostać zastosowany. + +## Przegląd skillu PR + +Ponieważ Tailspin Toys ma zestaw wymagań dotyczących tworzenia PR-ów, utworzyli skill, który pomaga narzędziom AI generować PR-y zgodne z tymi wytycznymi. Przejrzyjmy skill, aby zrozumieć, co zrobi. + +1. Otwórz `.github/skills/make-contribution/SKILL.md`. +2. Zwróć uwagę na nazwę i opis. Zauważ, jak opis podkreśla scenariusz użycia — zawsze gdy prosisz o utworzenie pull requestu lub commitowanie kodu. +3. Przeczytaj skill. Zwróć uwagę na reguły dotyczące tworzenia gałęzi, generowania commitów oraz zawartości pull requestu. + +## Użycie skillu + +Jak wspomniano wcześniej, skille są automatycznie wywoływane przez Copilot CLI. Wystarczy więc poprosić Copilota o utworzenie PR! + +1. Wróć do codespace. Jeśli go zamknąłeś, przejdź do repozytorium na GitHub.com, wybierz **Code** > **Codespaces**, a następnie ponownie otwórz istniejący codespace. +2. Wróć do otwartej sesji Copilot CLI. Jeśli terminal jest zamknięty lub wyszedłeś z Copilot CLI, otwórz terminal. Użyj kombinacji Ctrl+\`, a następnie uruchom go z katalogu głównego repozytorium poleceniem `copilot --yolo --enable-all-github-mcp-tools`. Zaufaj folderowi projektu, jeśli zostaniesz o to poproszony, potem wywołaj polecenie `/models` i wybierz **Auto**. +3. Poproś Copilota o utworzenie PR, używając poniższego polecenia: + + ``` + Can you please create a pull request for me! + ``` + +4. Copilot potwierdzi żądanie. Po chwili zauważysz, że Copilot wskaże, iż korzysta ze skillu **make-contribution**. +5. Następnie Copilot będzie postępował zgodnie z instrukcjami w skillu. Zacznie od uruchomienia testów, potem utworzy gałąź, committy i w końcu PR. +6. Gdy PR zostanie utworzony, wróć do repozytorium i otwórz PR. Zwróć uwagę, że sekcje odpowiadają wytycznym ze skillu i wymaganiom zespołu. +7. Przed przejściem do następnego ćwiczenia zresetuj lokalny obszar roboczy do świeżej gałęzi z `main`, aby praca nad usprawnieniami dostępności pozostała oddzielona od poprzedniego PR dotyczącego filtrowania: + + ```bash + git checkout main + git pull + git checkout -b accessibility-cli + ``` + +## Podsumowanie i kolejne kroki + +Za pomocą skillu agenta utworzyłeś nowy PR zgodny z udokumentowanymi wymaganiami! Podczas tego ćwiczenia: + +- przejrzałeś istniejący skill do tworzenia pull requestów. +- nauczyłeś się, jak skille są wykorzystywane przez agenta AI. +- utworzyłeś PR zgodny z wytycznymi za pomocą skillu. + +W następnym kroku poznasz [agentów niestandardowych][next-lesson] — skille są idealne do zadań, ale do bardziej rozbudowanych operacji warto z nich skorzystać! + +## Zasoby + +- [O Agent Skills][about-agent-skills] +- [Specyfikacja Agent Skills][agent-skills-spec] +- [Repozytorium Agent Skills][agent-skills-repo] +- [Agent Skills w awesome-copilot][awesome-copilot-skills] + +[previous-lesson]: ../4-mcp/ +[next-lesson]: ../6-custom-agents/ +[about-agent-skills]: https://docs.github.com/copilot/concepts/agents/about-agent-skills +[awesome-copilot-skills]: https://github.com/github/awesome-copilot/tree/main/skills +[agent-skills-repo]: https://github.com/agentskills/agentskills +[agent-skills-spec]: https://agentskills.io/specification diff --git a/docs/pl-pl/cli/6-custom-agents.md b/docs/pl-pl/cli/6-custom-agents.md new file mode 100644 index 00000000..f574a6d4 --- /dev/null +++ b/docs/pl-pl/cli/6-custom-agents.md @@ -0,0 +1,100 @@ +--- +title: "Ćwiczenie 6 - Agenci niestandardowi z GitHub Copilot CLI" +authors: + - geektrainer + - azkel +lastUpdated: 2026-09-10 +--- + +## Czym są agenci niestandardowi? + +[Agenci niestandardowi][custom-agents-concept] w GitHub Copilot pozwalają tworzyć wyspecjalizowanych asystentów AI dostosowanych do konkretnych zadań lub domen w trakcie pracy programistycznej. Definiując agentów przez pliki markdown w folderze `.github/agents` repozytorium, możesz dać Copilotowi skupione instrukcje, dobre praktyki, wzorce kodowania i wiedzę domenową, które pomagają mu skuteczniej wykonywać określone typy pracy. Zespoły mogą konsolidować swoją wiedzę w agentach wielokrotnego użytku — agent dostępności egzekwujący zgodność z [WCAG][wcag], agent bezpieczeństwa stosujący praktyki bezpiecznego programowania albo agent testujący utrzymujący spójne wzorce testów. + +Agenci niestandardowi są definiowani plikami markdown w folderze `.github/agents` projektu albo globalnie w `~/.copilot/agents`. Każdy plik ma nagłówek YAML z co najmniej polami `name` i `description`, a następnie treść markdown definiującą zachowanie, ekspertyzę i instrukcje agenta. + +### Agenci niestandardowi a skille agenta + +Między agentami niestandardowymi a [skillami agenta][agent-skills-concept] jest pewne logiczne zachodzenie. Oba są głównie definiowane plikami markdown i mówią naszemu AI, jak wykonywać operacje. Najczystszy sposób rozróżnienia: **agent niestandardowy** to pracownik, a **skille** to narzędzia. + +Agenci niestandardowi mają własne okno kontekstu i są zbudowani do orkiestracji skilli (a nawet innych agentów) w ramach swojej pracy. W tych warsztatach agent niestandardowy dostępności przegląda i aktualizuje witrynę pod kątem wytycznych dostępności; w ramach tej pracy może wywoływać skille, takie jak skill przepływu pull requestów lub skill uruchamiający i zarządzający testami. + +> [!NOTE] +> Nie ma jednej „właściwej” metody tworzenia agenta niestandardowego. Jak w każdym przypadku pracy z AI, testuj i iteruj, aby znaleźć to, co działa w Twoich środowiskach i scenariuszach. + +## Scenariusz + +Wiele aplikacji webowych nie jest w pełni dostępnych dla wszystkich użytkowników, a witryna, nad którą pracujesz, nie jest wyjątkiem. Użyjesz agenta niestandardowego do zidentyfikowania i usunięcia braków dostępności. + +Tailspin Toys zobowiązuje się, by ich platforma crowdfundingowa była dostępna dla wszystkich użytkowników, niezależnie od możliwości wzrokowych czy preferencji. Niedawna opinia użytkowników wskazała, że niektórzy uznają obecny ciemny motyw za trudny do odczytania z powodu niewystarczającego kontrastu między tekstem a kolorami tła. Aby rozwiązać ten problem dostępności, zespół projektowy poprosił o implementację trybu wysokiego kontrastu, który użytkownicy mogą włączać i wyłączać. + +Ponieważ dostępność jest krytyczna, chcesz wdrożyć to jak najszybciej. Użyjesz agenta niestandardowego do wygenerowania funkcjonalności. + +Podczas tego ćwiczenia: + +- poznasz agentów niestandardowych. +- włączysz agenta niestandardowego i przypiszesz mu zadanie w Copilot CLI. + +## Przegląd agenta niestandardowego dostępności + +Agent niestandardowy dostępności został już dla Ciebie utworzony. Przejrzyjmy jego treść, aby zrozumieć, jak pokieruje Copilotem. + +1. Otwórz `.github/agents/accessibility.md`. +2. Zwróć uwagę na nagłówek YAML z polami `name` i `description`. + +> [!CAUTION] +> Nagłówek z `name` i `description` jest wymagany dla agentów niestandardowych. + +3. Następnie przejrzyj kolejne sekcje, które podkreślają: + - Główne obowiązki przy generowaniu kodu dla dostępnej witryny. + - Dobre praktyki dostępności. + - Przykłady kodu dla HTML, CSS i JavaScript. + - Listę typowych pułapek i błędów. + +## Użycie agenta niestandardowego w Copilot CLI + +Możesz uruchomić agenta niestandardowego w Copilot CLI poleceniem `/agent`. Wykonajmy przegląd dostępności naszej witryny. + +1. Wróć do codespace. Jeśli go zamknąłeś, przejdź do repozytorium na GitHub.com, wybierz **Code** > **Codespaces**, a następnie ponownie otwórz istniejący codespace. +2. Wróć do otwartej sesji Copilot CLI. Jeśli terminal jest zamknięty lub wyszedłeś z Copilot CLI, otwórz terminal. Użyj kombinacji Ctrl+\`, a następnie uruchom go z katalogu głównego repozytorium poleceniem `copilot --yolo --enable-all-github-mcp-tools`. Zaufaj folderowi projektu, jeśli zostaniesz o to poproszony, potem uruchom `/models` i wybierz **Auto**. +3. Wyświetl listę agentów: wpisz `/agent` w interfejsie Copilot CLI i wciśnij Enter. +4. Wybierz **Accessibility agent** z listy dostępnych agentów. +5. Użyj poniższego polecenia, aby poprosić agenta dostępności o przegląd i wygenerowanie poprawek dla elementu backlogu dotyczącego dostępności: + + ``` + Perform an accessibility review of the site. Pull the related issue down from the repository for details. Implement a high-contrast mode toggle that persists the user's preference across page reloads. Ensure there are e2e tests for any updates made to the project. Then create a PR with the updates. + ``` + +6. Copilot zabierze się do pracy! Zacznie od pobrania zgłoszenia, potem wykona przegląd, wprowadzi zmiany i na koniec utworzy PR. Powinieneś też zauważyć, że przy tworzeniu PR korzysta ze skillu skoncentrowanego na PR-ach w projekcie. + +> [!NOTE] +> Ten proces prawdopodobnie zajmie kilka minut. To dobra chwila, by zastanowić się nad wszystkim, czego się nauczyłeś, napić się czegoś albo zajrzeć do następnego modułu o dodatkowych poleceniach dostępnych w Copilot CLI. + +## Podsumowanie i kolejne kroki + +To ćwiczenie omówiło [agentów niestandardowych][custom-agents] w GitHub Copilot — wyspecjalizowanych asystentów AI dostosowanych do konkretnych zadań i domen. Dzięki agentom niestandardowym możesz opisywać sposób pracy i standardy zespołu w agentach wielokrotnego użytku, które pomagają Copilotowi skuteczniej wykonywać określone typy pracy. + +Poznałeś następujące pojęcia: + +- jak definiuje się agentów niestandardowych. +- użycie agenta niestandardowego w Copilot CLI. + +W następnym kroku poznasz [kilka poleceń slash][next-lesson], pozwalających odkryć dodatkowe triki z Copilot CLI. + +## Zasoby + +- [Agenci niestandardowi][custom-agents] +- [Tworzenie agentów niestandardowych dla repozytorium][creating-custom-agents] +- [Agenci niestandardowi w awesome-copilot][awesome-copilot-agents] +- [Przygotowanie do używania agentów niestandardowych w organizacji][org-custom-agents] +- [Przygotowanie do używania agentów niestandardowych w przedsiębiorstwie][enterprise-custom-agents] + +[previous-lesson]: ../5-agent-skills/ +[next-lesson]: ../7-slash-commands/ +[custom-agents]: https://docs.github.com/copilot/how-tos/use-copilot-agents/use-copilot-cli#use-custom-agents +[creating-custom-agents]: https://docs.github.com/copilot/how-tos/use-copilot-agents/cloud-agent/create-custom-agents +[awesome-copilot-agents]: https://github.com/github/awesome-copilot/tree/main/agents +[org-custom-agents]: https://docs.github.com/copilot/how-tos/administer-copilot/manage-for-organization/prepare-for-custom-agents +[enterprise-custom-agents]: https://docs.github.com/copilot/how-tos/administer-copilot/manage-for-enterprise/manage-agents/prepare-for-custom-agents +[custom-agents-concept]: https://docs.github.com/copilot/concepts/agents/cloud-agent/about-custom-agents +[agent-skills-concept]: https://docs.github.com/copilot/concepts/agents/about-agent-skills +[wcag]: https://www.w3.org/WAI/standards-guidelines/wcag/ diff --git a/docs/pl-pl/cli/7-slash-commands.md b/docs/pl-pl/cli/7-slash-commands.md new file mode 100644 index 00000000..94c510f6 --- /dev/null +++ b/docs/pl-pl/cli/7-slash-commands.md @@ -0,0 +1,162 @@ +--- +title: "Ćwiczenie 7 - Polecenia slash w GitHub Copilot CLI" +authors: + - geektrainer + - azkel +lastUpdated: 2026-09-10 +--- + +Jak każde dobre narzędzie CLI, GitHub Copilot CLI zawiera wiele poleceń slash pozwalających wchodzić w zaawansowane interakcje. Te polecenia udostępniają zaawansowane funkcje, informacje „za kulisami” lub dodatkowe opcje konfiguracji. Już poznałeś kilka z nich: `/clear` do czyszczenia kontekstu i `/mcp` do przeglądania serwerów MCP. Przyjrzyjmy się kilku bardziej zaawansowanym, w tym `/context`, `/model`, `/share` i `/delegate`. + +## Scenariusz + +Zakończyłeś podstawowe przepływy CLI. Spójrzmy teraz na kilka dodatkowych możliwości — udostępnianie sesji, przełączanie modeli i delegowanie zadań do [agentów chmurowych Copilot][about-cloud-agent]. + +Podczas tego ćwiczenia użyjesz: + +- `/share` do utworzenia gista GitHub, aby udostępnić sesję zespołowi. +- `/context`, aby zobaczyć kontekst, którego obecnie używa Copilot CLI. +- `/model`, aby przejrzeć listę dostępnych modeli i w razie potrzeby wybrać nowy. +- `/delegate`, aby opcjonalnie przekazać zadanie do cloud agent. Wymaga to cloud agent, dostępnego w planach Copilot Student, Pro, Pro+, Business lub Enterprise — w każdym planie oprócz Copilot Free. + +## Udostępnianie sesji + +Korzystanie z dowolnego narzędzia, w tym AI, to umiejętność, którą trzeba nabyć. Wspólna praca w zespole i dzielenie się wnioskami to najlepszy sposób na poprawę doświadczenia wszystkich i generowanie kodu wyższej jakości. W tym celu Copilot CLI oferuje polecenie `/share`. Polecenie `/share` może wygenerować plik markdown lub gist GitHub ze szczegółami sesji, w tym użytymi poleceniami i logiką, którą podążał Copilot. + +Utwórzmy gist GitHub, który moglibyśmy udostępnić zespołowi. + +1. Wróć do codespace. Jeśli go zamknąłeś, przejdź do repozytorium na GitHub.com, wybierz **Code** > **Codespaces**, a następnie ponownie otwórz istniejący codespace. +2. Wróć do otwartej sesji Copilot CLI. Jeśli terminal jest zamknięty lub wyszedłeś z Copilot CLI, otwórz terminal. Użyj kombinacji Ctrl+\`, a następnie uruchom go z katalogu głównego repozytorium poleceniem `copilot --yolo --enable-all-github-mcp-tools`. Zaufaj folderowi projektu, jeśli zostaniesz o to poproszony, potem uruchom `/model` i wybierz **Auto**. +3. W interfejsie Copilot CLI wyślij poniższe polecenie: + + ``` + /share gist + ``` + +4. Po chwili Copilot utworzy gist i wyświetli link. +5. Skopiuj tekst linku. +6. W nowej karcie przeglądarki wklej link, aby przejrzeć gist. Zwróć uwagę, jak gist podkreśla wysłane polecenia, użyte skille i agentów, tok myślenia Copilota, a nawet kod i wyniki lokalnie uruchomionych poleceń. + +Gisty i pliki markdown generowane przez `/share` mogą służyć do dokumentowania sposobu generowania kodu albo do dzielenia się z zespołem tym, jak wykonano określone działania, które dały pożądane wyniki od Copilota. + +## Przegląd kontekstu Copilot CLI + +Przy większych lub bardziej złożonych zadaniach możesz dojść do maksymalnego okna kontekstu modelu. Dokładny rozmiar okna zależy od używanego modelu i wersji Copilot CLI. Gdy okno kontekstu się zapełni, Copilot CLI automatycznie je skompaktuje, podsumowując informacje i usuwając to, co uzna za nieistotne dla bieżącego zadania. Możesz zarówno zobaczyć bieżący stan kontekstu, jak i ręcznie skompaktować kontekst poleceniami slash. Przyjrzyjmy się oknu kontekstu. + +1. W interfejsie Copilot CLI wyślij poniższe polecenie: + + ``` + /context + ``` + +2. W ciągu chwili Copilot CLI wygeneruje wizualną reprezentację bieżącego kontekstu: + + ![Zrzut ekranu okna kontekstu z Copilot CLI](../../_images/cli-7-context-window.png) + +3. Zwróć uwagę na wyświetlony model (może różnić się od tego na obrazku) oraz bieżący procent użytych tokenów. Pozostałe informacje podkreślają: + + | Tytuł | Opis | + | ---------------------- | ------------------------------------------------------ | + | System/Tools (system/narzędzia) | Pliki instrukcji, zawartość plików i definicje narzędzi | + | Messages (wiadomości) | Historia rozmowy między Tobą a Copilotem | + | Buffer (bufor) | Zarezerwowane miejsce przez Copilot CLI na generowanie odpowiedzi | + | Free space (wolne) | Pozostałe wolne miejsce | + +4. Skompaktuj historię rozmowy, wysyłając do Copilot CLI poniższe polecenie slash: + + ``` + /compact + ``` + +5. Po zakończeniu wyślij poniższe polecenie, aby ponownie wyświetlić bieżące statystyki kontekstu: + + ``` + /context + ``` + +6. Zwróć uwagę na zmianę kontekstu. Może nie być drastyczna, ponieważ okno kontekstu jest obecnie prawdopodobnie stosunkowo małe. + +> [!NOTE] +> Copilot CLI automatycznie kompaktuje kontekst, gdy się zapełni. Gdy zbliża się do 100% pojemności, wyświetla procent tuż nad interfejsem. Zwykle kompaktuje asynchronicznie, pozwalając Ci dalej wchodzić w interakcję z Copilotem podczas pracy. Może jednak zablokować działającą operację na kilka sekund na czas kompaktowania. + +### Dobre praktyki dotyczące kontekstu + +W większości sesji z Copilotem kontekst jest efektywnie zarządzany przez samego Copilota bez szczególnych wskazówek. Czasem jednak zdecydujesz się ręcznie polecić Copilotowi wyczyszczenie lub skompaktowanie historii: + +- Jeśli przechodzisz do innej części aplikacji albo do niezwiązanego zadania, możesz użyć `/clear`, aby zacząć od nowa i uniknąć zmylenia Copilota starszym, niepowiązanym kontekstem. +- Jeśli zbliżasz się do maksymalnego okna kontekstu, możesz ręcznie wykonać `/compact`, aby kontrolować moment kompaktowania. + +> [!CAUTION] +> Ponownie — w większości przypadków Copilot zarządza kontekstem bez Twojej bezpośredniej interakcji. Jeśli zauważysz, że Copilot jest nieco zdezorientowany starszymi informacjami, albo zamierzasz przejść do niezwiązanego zadania, rozważ użycie tych poleceń samodzielnie. + +## Wybór modelu + +Różne modele mają różne mocne strony, a różni deweloperzy mają różne preferencje. Copilot CLI pozwala wyświetlać listę modeli i wybierać model, którego chcesz użyć! + +1. Wyświetl listę modeli, wysyłając do Copilot CLI poniższe polecenie slash: + + ``` + /model + ``` + +2. Zwróć uwagę na listę modeli. Każdy model ma nazwę oraz mnożnik kosztu na żądanie. +3. Jeśli chcesz, wybierz nowy model! Albo wciśnij Esc, aby wyjść z listy modeli. + +> [!CAUTION] +> Wybór modelu jest zapamiętywany w Copilot CLI. + +## Delegowanie do agenta w chmurze (opcjonalne) + +Czasem chcesz dalej pracować w terminalu, ale przekazać dłuższe zadanie do agenta Copilot w chmurze. Polecenie `/delegate` wysyła bieżącą sesję Copilot CLI na GitHub.com, gdzie agent chmurowy ją przejmuje, będzie nad nią pracować asynchronicznie i po zakończeniu otwiera pull request. + +> [!NOTE] +> `/delegate` wymaga agentów chmurowych, dostępnych w planach Copilot Student, Pro, Pro+, Business lub Enterprise — w każdym planie oprócz Copilot Free. Jeśli nie masz dostępu, przeczytaj tę sekcję i pomiń kroki treningowe. + +1. Najpierw wyczyść bieżącą sesję, aby nie delegować zgromadzonego kontekstu tych warsztatów: + + ``` + /clear + ``` + +2. Wyślij małe, dobrze określone polecenie. Na przykład możesz oddelegować paginację z dodatkowych celów (stretch goal) z backlogu: + + ``` + Implement pagination on the game list page so it shows a fixed number of games per page with Previous and Next controls, and add tests. + ``` + +3. Wyślij poniższe polecenie slash, aby przekazać sesję do agenta w chmurze, i przejrzyj polecenie, które chcesz oddelegować: + + ``` + /delegate + ``` + +4. Otwórz [Copilot agents](https://github.com/copilot/agents) w przeglądarce, aby monitorować postęp. +5. Nie musisz czekać na ukończenie pull requestu w tym środowisku; możesz wrócić do niego później. Jeśli chcesz głębiej poznać zarządzanie asynchroniczną pracą agentów, kontynuuj ze [środowiskiem Cloud agent](../../cloud/). + +## Podsumowanie i kolejne kroki + +Polecenia slash w Copilot CLI pozwalają konfigurować jego zachowanie, udostępniać sesje i uzyskiwać wewnętrzne informacje o tym, jak Copilot pracuje. Podczas tego ćwiczenia użyłeś lub poznałeś: + +- `/share` do utworzenia gista GitHub, aby udostępnić sesję zespołowi. +- `/context`, aby zobaczyć kontekst, którego obecnie używa Copilot CLI. +- `/model`, aby przejrzeć listę dostępnych modeli i w razie potrzeby wybrać nowy. +- `/delegate` jako opcjonalny most do cloud agent. + +Jest oczywiście więcej dostępnych poleceń slash i więcej do odkrycia z Copilot CLI! W następnym kroku [przejrzyj to, czego się nauczyłeś][next-lesson], oraz kolejne kroki pozwalające na dalszą naukę. + +## Zasoby + +- [Korzystanie z Copilot CLI][using-copilot-cli] +- [O Copilot CLI][about-copilot-cli] +- [Zarządzanie kontekstem w Copilot CLI][context-management] +- [Udostępnianie sesji z Copilot CLI][share-sessions] +- [Wybór modeli w Copilot CLI][selecting-models] + +[previous-lesson]: ../6-custom-agents/ +[next-lesson]: ../8-review/ +[using-copilot-cli]: https://docs.github.com/copilot/how-tos/use-copilot-agents/use-copilot-cli +[about-copilot-cli]: https://docs.github.com/copilot/concepts/agents/about-copilot-cli +[about-cloud-agent]: https://docs.github.com/copilot/concepts/agents/cloud-agent/about-cloud-agent +[context-management]: https://docs.github.com/copilot/how-tos/use-copilot-agents/use-copilot-cli#context-management +[share-sessions]: https://docs.github.com/copilot/how-tos/use-copilot-agents/use-copilot-cli#share-sessions +[selecting-models]: https://docs.github.com/copilot/how-tos/use-copilot-agents/use-copilot-cli#select-an-llm diff --git a/docs/pl-pl/cli/8-review.md b/docs/pl-pl/cli/8-review.md new file mode 100644 index 00000000..5d32d189 --- /dev/null +++ b/docs/pl-pl/cli/8-review.md @@ -0,0 +1,71 @@ +--- +title: "Ćwiczenie 8 - Podsumowanie i kolejne kroki" +authors: + - geektrainer + - azkel +lastUpdated: 2026-09-10 +--- + +W ostatnich ćwiczeniach poznałeś niektóre z najczęstszych przypadków użycia GitHub Copilot CLI, w tym: + +- interakcję z GitHubem i innymi serwerami MCP. +- używanie plików instrukcji do kierowania generowaniem kodu. +- implementację skilli dodających narzędzia do funkcjonalności Copilot CLI. +- wywoływanie agentów niestandardowych do zaawansowanych i bardziej złożonych zadań. +- używanie poleceń slash do zarządzania sesją oraz opcjonalne łączenie z agentami w chmurze przez `/delegate`. + +Omówmy kilka poleceń slash, dobre praktyki i kolejne kroki. + +## Polecenia slash + +Copilot CLI ma szereg poleceń slash do interakcji z nim, w tym takie, które pozwalają go dokładniej skonfigurować lub zobaczyć, co dzieje się za kulisami. Już użyłeś `/clear`, aby rozpocząć nową rozmowę czyszczącą bieżący kontekst, oraz `/mcp` do przeglądania i zarządzania serwerami MCP. Kilka dodatkowych, które mogą być pomocne: + +| Polecenie | Opis | +| ------------------ | ------------------------------------------------------------- | +| `/add-dir` | Dodaj katalog do listy zaufanych dla Copilota | +| `/clear`, `/new` | Wyczyść historię rozmowy i zacznij od nowa | +| `/compact` | Podsumuj historię rozmowy, aby zmniejszyć użycie okna kontekstu | +| `/context` | Pokaż użycie tokenów okna kontekstu i wizualizację | +| `/diff` | Przejrzyj zmiany wprowadzone w bieżącym katalogu | +| `/model` | Wybierz model AI do użycia (Claude Sonnet, GPT-5 itd.) | +| `/plan ` | Utwórz plan implementacji przed kodowaniem | +| `/review ` | Uruchom agenta przeglądu kodu do analizy zmian | +| `/delegate` | Deleguj zadanie do agenta Copilot w chmurze do przetwarzania asynchronicznego | +| `/session` | Pokaż informacje o sesji i podsumowanie obszaru roboczego | +| `/share` | Udostępnij sesję do pliku markdown lub gista GitHub | +| `/skills` | Zarządzaj skillami w celu rozszerzenia możliwości | +| `/usage` | Wyświetl metryki i statystyki użycia sesji | + +> [!TIP] +> Użyj `/help`, aby zobaczyć pełną listę dostępnych poleceń i skrótów klawiszowych. + +## Dobre praktyki + +Przy korzystaniu z dowolnego narzędzia AI jakość wyniku w dużej mierze zależy od przygotowanej infrastruktury. Solidne pliki instrukcji, agenci niestandardowi i skille agenta odgrywają rolę — każde z nich poznałeś w tych warsztatach. [awesome-copilot][awesome-copilot] to dobre źródło szablonów, a sam Copilot może wygenerować ich szkielet jako punkt startowy. + +Kontekst nadal ma znaczenie tak samo jak infrastruktura. Jasne opisanie *czego* chcesz, *dlaczego* i *jak* znacząco zmienia wynik. Jeśli jakaś informacja pomoże Copilotowi — przekaż ją. + +## Kolejne kroki + +Najlepszym sposobem na poprawę umiejętności z dowolnym narzędziem jest wykorzystanie go do dalszych eksperymentów i pracy! Używaj go do kodu produkcyjnego, hobbystycznego, do tej małej aplikacji, którą masz w głowie od lat, ale nigdy nie zabrałeś się do budowy. Dziel się wnioskami z zespołem i ucz się od zespołu. I jak zawsze — przeglądaj dokumentację. + +Jeśli chcesz poznać więcej ekosystemu GitHub Copilot, zobacz [środowisko VS Code](../../vscode/) lub [środowisko Cloud agent](../../cloud/). + +## Zasoby + +- [O Copilot CLI][about-copilot-cli] +- [Korzystanie z Copilot CLI][using-copilot-cli] +- [Repozytorium Awesome Copilot][awesome-copilot] +- [Przewodnik po instrukcjach niestandardowych][repo-instructions] +- [Dokumentacja Agent Skills][agent-skills] +- [Dokumentacja agentów niestandardowych][custom-agents] +- [Specyfikacja MCP][mcp-spec] + +[previous-lesson]: ../7-slash-commands/ +[about-copilot-cli]: https://docs.github.com/copilot/concepts/agents/about-copilot-cli +[using-copilot-cli]: https://docs.github.com/copilot/how-tos/use-copilot-agents/use-copilot-cli +[awesome-copilot]: https://github.com/github/awesome-copilot +[repo-instructions]: https://docs.github.com/copilot/how-tos/configure-custom-instructions/add-repository-instructions +[agent-skills]: https://docs.github.com/copilot/concepts/agents/about-agent-skills +[custom-agents]: https://docs.github.com/copilot/how-tos/use-copilot-agents/use-copilot-cli#use-custom-agents +[mcp-spec]: https://modelcontextprotocol.io/ diff --git a/docs/pl-pl/cli/README.md b/docs/pl-pl/cli/README.md new file mode 100644 index 00000000..e86a555d --- /dev/null +++ b/docs/pl-pl/cli/README.md @@ -0,0 +1,55 @@ +--- +slug: pl-pl/cli +title: "GitHub Copilot CLI" +authors: + - geektrainer + - azkel +lastUpdated: 2026-09-10 +--- + +**[GitHub Copilot CLI](https://docs.github.com/copilot/concepts/agents/about-copilot-cli)** umieszcza GitHub Copilot w terminalu jako agentycznego asystenta programowania. Eksploruje bazy kodu, generuje kod, uruchamia polecenia i łączy się z zewnętrznymi narzędziami — wszystko z linii poleceń, dzięki czemu możesz pozostać w przepływie pracy bez przełączania się na edytor graficzny. + +Podczas tych ćwiczeń zainstalujesz i uwierzytelnisz Copilot CLI, a następnie dasz mu kontekst projektu za pomocą instrukcji niestandardowych, zanim użyjesz trybu planowania do świadomego wygenerowania funkcji. Połączysz serwer Playwright MCP, aby przetestować tę funkcję w prawdziwej przeglądarce, a potem rozszerzysz Copilota o skille agenta wielokrotnego użytku i agentów niestandardowych. Na koniec poznasz polecenia slash do zarządzania kontekstem, modelami i udostępnianiem, a zakończysz przeglądem tego, co zbudowałeś. + +## Ćwiczenia + +| Ćwiczenie | Temat | Opis | +|----------|-------|-------------| +| [0. Wymagania wstępne][ex0] | Konfiguracja | Utwórz własną kopię repozytorium i codespace | +| [1. Instalacja Copilot CLI][ex1] | Instalacja | Zainstaluj i uwierzytelnij Copilot CLI | +| [2. Instrukcje niestandardowe][ex2] | Kontekst | Dodaj instrukcję i zobacz, jak Copilot CLI jej przestrzega | +| [3. Generowanie kodu][ex3] | Generowanie kodu | Użyj trybu planowania i generuj funkcje | +| [4. Testowanie z Playwright MCP][ex4] | Narzędzia zewnętrzne | Dodaj serwer Playwright MCP i przetestuj funkcję w przeglądarce | +| [5. Skille agenta][ex5] | Skille | Rozszerz Copilota o wyspecjalizowane skille | +| [6. Agenci niestandardowi][ex6] | Agenci | Przejrzyj i użyj agentów niestandardowych | +| [7. Polecenia slash][ex7] | Funkcje CLI | Poznaj kontekst, modele, udostępnianie i opcjonalne delegowanie do cloud agent | +| [8. Podsumowanie][ex8] | Podsumowanie | Przypomnij kluczowe pojęcia i kolejne kroki | + +## Wymagania wstępne + +Przed udziałem w tych warsztatach upewnij się, że masz: + +- [ ] Konto GitHub z aktywnym planem **Copilot Student, Pro, Pro+, Business lub Enterprise** +- [ ] Podstawową znajomość obsługi terminala/linii poleceń +- [ ] Zainstalowany i skonfigurowany Git + +> [!TIP] +> Brak płatnego planu? Zweryfikowani studenci mogą uzyskać GitHub Copilot za darmo przez [GitHub Education][callout-student-plan-education]. Plan **Copilot Student** obejmuje agenta, MCP, przegląd kodu i funkcje Copilot CLI używane w tych warsztatach — dzięki temu ukończysz każdą ze ścieżek. + +> [!NOTE] +> Jeśli korzystasz z Copilot Business lub Copilot Enterprise, upewnij się, że administrator włączył Copilot CLI. + +## Rozpocznij + +**[Zacznij od Ćwiczenia 0: Wymagania wstępne →][ex0]** + +[ex0]: 0-prerequisites/ +[ex1]: 1-install-copilot-cli/ +[ex2]: 2-custom-instructions/ +[ex3]: 3-generating-code/ +[ex4]: 4-mcp/ +[ex5]: 5-agent-skills/ +[ex6]: 6-custom-agents/ +[ex7]: 7-slash-commands/ +[ex8]: 8-review/ +[callout-student-plan-education]: https://github.com/education/students diff --git a/website/astro.config.mjs b/website/astro.config.mjs index 2abc22db..8ad7a101 100644 --- a/website/astro.config.mjs +++ b/website/astro.config.mjs @@ -36,6 +36,7 @@ export default defineConfig({ 'es-es': { label: 'Español', lang: 'es-ES' }, 'ja-jp': { label: '日本語', lang: 'ja-JP' }, 'ko-kr': { label: '한국어', lang: 'ko-KR' }, + 'pl-pl': { label: 'Polski', lang: 'pl-PL' }, 'pt-br': { label: 'Português (Brasil)', lang: 'pt-BR' }, 'zh-cn': { label: '简体中文', lang: 'zh-CN' }, },