@michaelbel/cuckcoder-mcp 1.6.11

package/assets/skills/interview-me/SKILL.md

@@ -0,0 +1,150 @@
+---
+name: interview-me
+description: >-
+  Use when требования расплывчаты, противоречат друг другу или короче, чем заслуживает задача —
+  перед тем как ставить acceptance criteria и делегировать реализацию. Триггерные фразы: "добавь
+  оффлайн", "сделай синхронизацию", "разберись сам", одна-две фразы на фичу, которая явно больше
+  одной фразы, противоречие между тем, что просит пользователь, и тем, что уже делает код.
+  Структурированный опрос малыми пачками вопросов вместо накопления предположений: поднимает
+  уверенность в требованиях до ~95%, прежде чем main-сессия сформулирует задачу профильному агенту
+  (`kotlin-engineer`, `compose-builder`, `swift-engineer`, `swiftui-builder`, `guide-android-builder`
+  и т.д.) или бизнес-аналитику `business-analyst`. Не используй, если задача маленькая и
+  однозначная (переименование, точечный багфикс с понятной причиной) или acceptance criteria уже
+  явно заданы пользователем/issue — в этом случае сразу делегируй по `rules/workflow.md`.
+metadata:
+  author: michaelbel
+---
+
+# Интервью с пользователем
+
+## Обзор
+
+Самый дешёвый баг — тот, что не написан, потому что нужный вопрос задали до реализации, а не после
+код-ревью. Этот skill заменяет накопление предположений структурированным интервью: задавай
+целевые вопросы малыми пачками, скармливай каждый ответ следующему раунду и останавливайся только
+тогда, когда acceptance criteria можно написать не выдумывая. Он выносит разговор, который иначе
+случится как rework после ревью, в начало — до того как задача уйдёт профильному агенту.
+
+## Когда использовать
+
+- Запрос на одну-две фразы описывает то, что явно больше одной-двух фраз ("добавь оффлайн-режим").
+- Требования противоречат друг другу или текущему поведению приложения/бэкенда.
+- Возможны несколько трактовок, и ошибиться в выборе дорого (миграция схемы, публичный контракт,
+  необратимое решение — см. также `doubt-driven-development`, если он у вас появится, либо сразу
+  `documentation-and-adrs`-практику для фиксации решения).
+- Перед тем как отдать задачу `business-analyst` на проверку acceptance criteria, или профильному
+  инженерному агенту на реализацию.
+- Пользователь говорит в духе "ты понимаешь, о чём я" — не понимаешь.
+
+**Не используй, если:** задача маленькая и однозначная (rename, точечный багфикс с понятной
+причиной), или acceptance criteria уже заданы явно пользователем/issue/спекой — тогда сразу
+делегируй по `rules/workflow.md`. Интервью не должно быть предлогом не начинать работу.
+
+## Процесс
+
+### Шаг 1. Зафиксируй, что уже понятно
+
+Прежде чем задавать вопросы, письменно зафиксируй текущее понимание и уровень уверенности:
+
+```markdown
+## Понимание: оффлайн-очередь мутаций задач
+- Пользователь видит закэшированные задачи офлайн — уверенно (сказано явно)
+- Пользователь может СОЗДАВАТЬ задачи офлайн — предположение, не сказано
+- Стратегия разрешения конфликтов — неизвестно
+- Триггер синка (при открытии приложения? WorkManager?) — неизвестно
+Уверенность: ~40%
+```
+
+Строки "предположение" и "неизвестно" становятся списком вопросов. Если таких строк не возникло —
+интервью не требовалось.
+
+### Шаг 2. Задавай вопросы малыми целевыми пачками
+
+3–5 вопросов за раунд, самое дорогое решение — первым. Один вопрос — одно решение, конкретные
+варианты вместо открытых формулировок:
+
+```markdown
+1. Если задачу отредактировали офлайн на двух устройствах, что побеждает при синке — последняя
+   запись или конфликт показывается пользователю?
+2. Создание задач должно работать офлайн, или в v1 офлайн — только чтение?
+3. Синк по открытию приложения или фоновый через WorkManager (с учётом Doze/App Standby)?
+4. Что происходит с несинканными офлайн-изменениями при логауте?
+```
+
+Правила вопросов:
+- Спрашивай про поведение, которое видит пользователь, а не про реализацию ("что побеждает?", а не
+  "OT или CRDT?").
+- Предлагай дефолт: "Предлагаю last-write-wins для v1 — годится?" — легко подтвердить, легко
+  поправить.
+- Поднимай платформенные реалии, которые заказчик может не знать: фоновые ограничения (Doze,
+  WorkManager retry/backoff), KMP-паритет поведения между Android и iOS (если фича общая для
+  `shared/`), реконнект realtime-канала (SignalR) после разрыва сети, требования Google
+  Play/App Store review.
+- Никогда не переспрашивай то, что уже закрыл предыдущий ответ.
+
+### Шаг 3. Скорми ответы обратно и итерируй
+
+После каждого раунда обнови документ понимания — перескажи ответы своими словами, отметь закрытые
+пункты, дай новым вопросам возникнуть из ответов:
+
+```markdown
+Закрыто: офлайн-чтение и создание в v1; last-write-wins; синк по открытию приложения.
+Новый вопрос из "last-write-wins": тихая потеря данных при конфликте — ок, или логировать для
+саппорта?
+Уверенность: ~80%
+```
+
+### Шаг 4. Останавливайся на ~95% и передавай дальше
+
+Выходи из интервью, когда каждый acceptance criterion можно написать не выдумывая. Идеальная
+уверенность — не цель; оставшиеся ~5% фиксируются как явные предположения:
+
+```markdown
+Предположения (продолжаем, пока не поправят):
+- Конфликты достаточно редки, чтобы тихий last-write-wins был приемлем для v1.
+```
+
+Передай результат дальше по `rules/workflow.md`: если решение архитектурное или необратимое —
+сначала `business-analyst` на проверку с продуктовой стороны и/или ADR по
+`documentation-and-adrs`-практике; реализацию отдай профильному агенту (`kotlin-engineer`,
+`compose-builder`, `swift-engineer`, `swiftui-builder`) вместе с документом понимания как частью
+постановки задачи — не как отдельное сообщение, которое потеряется в чате. Для оффлайн-очереди
+из примера выше следующий шаг обычно — `create-offline-outbox`.
+
+## Типичные отговорки
+
+| Отговорка | Почему не работает |
+|---|---|
+| "Сделаю разумные предположения и отмечу их" | Десять сложенных "разумных" предположений дают неразумный результат. Предположения — для последних 5%, а не для первых 50%. |
+| "Задавать вопросы — выглядит неуверенно" | Реализация не того выглядит хуже. Хорошие вопросы демонстрируют понимание задачи. |
+| "Пользователь занят, не буду дёргать" | Пять минут его времени сейчас дешевле недели переделки и более тяжёлого разговора потом. |
+| "Разберусь по ходу реализации" | Структурные решения (модель офлайна, стратегия конфликтов) дёшево менять в разговоре и дорого — в коде. |
+| "Один большой список вопросов эффективнее" | Двадцать вопросов разом просто пролистают. Маленькие пачки получают настоящие ответы, а ответы меняют следующие вопросы. |
+| "Передам неопределённость профильному агенту, он разберётся по контексту" | Профильный агент реализует, а не уточняет продуктовые решения — по `rules/workflow.md` он получает уже поставленную задачу. Нерешённая неоднозначность в постановке становится неверной реализацией, а не вопросом. |
+
+## Красные флаги
+
+- Реализация начата, а документ понимания всё ещё содержит "неизвестно" по ключевому поведению.
+- Вопросы про детали реализации, а не про видимое пользователю поведение.
+- Задача делегирована профильному агенту с нерешённой неоднозначностью вместо того, чтобы закрыть
+  её в main-сессии до делегирования.
+- Один и тот же вопрос задан дважды, потому что ответ не зафиксировали.
+- Ноль зафиксированных предположений в задаче, где неоднозначность точно была (значит, их сделали
+  молча).
+- Стена из двадцати вопросов одним сообщением.
+- "Интервью" продолжается после того, как acceptance criteria уже можно написать — это уже
+  затягивание, а не уточнение.
+
+## Чек-лист
+
+- [ ] Документ понимания существует и явно делит пункты на подтверждённые / предположенные /
+      неизвестные.
+- [ ] Каждое видимое пользователю поведение закрыто ответом или явным предположением — без тихих
+      пробелов.
+- [ ] Оставшиеся предположения записаны и показаны пользователю, а не оставлены только в голове
+      агента.
+- [ ] Acceptance criteria можно сформулировать, ничего не выдумывая.
+- [ ] Платформенные ограничения стека (Doze/WorkManager, KMP-паритет Android/iOS, реконнект
+      realtime, Play/App Store review) подняты там, где релевантны.
+- [ ] Результат передан дальше как часть постановки задачи для `business-analyst` и/или
+      профильного агента — по `rules/workflow.md`, а не потерян в чате.

package/dist/errors.js

@@ -0,0 +1,49 @@
+const RETRYABLE_CODES = new Set([
+    "GITHUB_TIMEOUT",
+    "GITHUB_RATE_LIMITED",
+    "GITHUB_UNREACHABLE",
+]);
+/**
+ * The one shared error shape for this server. Every tool handler catches its own errors and
+ * converts them (via toToolErrorResult) into this shape rather than letting an exception escape
+ * unhandled and crash the process.
+ */
+export class WorkflowError extends Error {
+    code;
+    retryable;
+    details;
+    constructor(code, message, options = {}) {
+        super(message);
+        this.name = "WorkflowError";
+        this.code = code;
+        this.retryable = options.retryable ?? RETRYABLE_CODES.has(code);
+        this.details = options.details;
+    }
+}
+export function toErrorPayload(error) {
+    if (error instanceof WorkflowError) {
+        return {
+            code: error.code,
+            message: error.message,
+            retryable: error.retryable,
+            details: error.details,
+        };
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+        code: "INTERNAL_ERROR",
+        message,
+        retryable: false,
+    };
+}
+/**
+ * Converts any thrown value into an MCP tool error result. Never throws itself, so it is safe to
+ * call from a top-level catch in every tool handler.
+ */
+export function toToolErrorResult(error) {
+    const payload = toErrorPayload(error);
+    return {
+        content: [{ type: "text", text: JSON.stringify(payload) }],
+        isError: true,
+    };
+}

package/dist/frontmatter.js

@@ -0,0 +1,44 @@
+const FRONTMATTER_PATTERN = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+/**
+ * Minimal YAML-frontmatter parser for our own SKILL.md files.
+ *
+ * Supports single-line `key: value` fields and a folded block scalar
+ * (`key: >-` followed by indented continuation lines, joined with single spaces), which is the
+ * only multi-line form used by skills/*\/SKILL.md descriptions. This is intentionally not a
+ * general-purpose YAML parser.
+ */
+export function parseFrontmatter(markdown) {
+    const match = markdown.match(FRONTMATTER_PATTERN);
+    if (!match) {
+        return { fields: {}, body: markdown };
+    }
+    const rawFrontmatter = match[1];
+    const body = match[2] ?? "";
+    const lines = rawFrontmatter.split(/\r?\n/);
+    const fields = {};
+    let index = 0;
+    while (index < lines.length) {
+        const line = lines[index];
+        const fieldMatch = line.match(/^([a-zA-Z_][a-zA-Z0-9_]*):\s*(.*)$/);
+        if (!fieldMatch) {
+            index += 1;
+            continue;
+        }
+        const key = fieldMatch[1];
+        const rest = fieldMatch[2];
+        if (rest === ">-" || rest === "|-" || rest === ">" || rest === "|") {
+            const foldedLines = [];
+            index += 1;
+            while (index < lines.length && (lines[index].startsWith("  ") || lines[index].trim() === "")) {
+                foldedLines.push(lines[index].replace(/^ {2}/, ""));
+                index += 1;
+            }
+            const joiner = rest === "|-" || rest === "|" ? "\n" : " ";
+            fields[key] = foldedLines.join(joiner).trim();
+            continue;
+        }
+        fields[key] = rest.trim();
+        index += 1;
+    }
+    return { fields, body };
+}

package/dist/github.js

@@ -0,0 +1,23 @@
+const BASE_RAW = "https://raw.githubusercontent.com";
+const BASE_API = "https://api.github.com";
+export async function fetchFile(owner, repo, branch, path) {
+    const url = `${BASE_RAW}/${owner}/${repo}/${branch}/${path}`;
+    const res = await fetch(url);
+    if (!res.ok) {
+        throw new Error(`Not found: ${path} (HTTP ${res.status})`);
+    }
+    return res.text();
+}
+export async function listTree(owner, repo, branch) {
+    const url = `${BASE_API}/repos/${owner}/${repo}/git/trees/${branch}?recursive=1`;
+    const res = await fetch(url, {
+        headers: { Accept: "application/vnd.github.v3+json" },
+    });
+    if (!res.ok) {
+        throw new Error(`Failed to fetch tree (HTTP ${res.status})`);
+    }
+    const data = (await res.json());
+    return data.tree
+        .filter((item) => item.type === "blob")
+        .map((item) => item.path);
+}

package/dist/index.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createServer } from "./server.js";
+const server = createServer();
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/server.js

@@ -0,0 +1,131 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { toToolErrorResult } from "./errors.js";
+import { createSource } from "./source/index.js";
+import { validateRuleName, validateSkillName } from "./validation.js";
+import { getServerName, getServerVersion } from "./version.js";
+const SERVER_INSTRUCTIONS = [
+    "Use this server as the source of truth for Cuckcoder rules and skills.",
+    "Before any git commit, call get_rule with name 'git' and apply the returned rules.",
+    "Before deleting files, call get_rule with name 'filesystem' and apply the returned rules.",
+].join("\n");
+const sourceOutputShape = {
+    kind: z.enum(["bundled", "github"]),
+    ref: z.string(),
+};
+/**
+ * Builds the MCP server and registers its tools. Contains no transport/connect logic, so it can
+ * be constructed and exercised directly in tests without spawning a process or opening stdio.
+ */
+export function createServer(options = {}) {
+    const env = options.env ?? process.env;
+    const source = options.source ?? createSource(env, options.fetchImpl);
+    const sourceInfo = source.info();
+    const readOnlyHint = true;
+    const openWorldHint = sourceInfo.kind === "github";
+    const server = new McpServer({ name: getServerName(), version: getServerVersion() }, { instructions: SERVER_INSTRUCTIONS });
+    // ─── list ──────────────────────────────────────────────────────────────────
+    server.registerTool("list", {
+        title: "List rules and skills",
+        description: "List all available rule names and skill names/descriptions in the Cuckcoder repository.",
+        inputSchema: {},
+        outputSchema: {
+            rules: z.array(z.string()),
+            skills: z.array(z.object({ name: z.string(), description: z.string() })),
+            source: z.object(sourceOutputShape),
+        },
+        annotations: {
+            title: "List rules and skills",
+            readOnlyHint,
+            openWorldHint,
+        },
+    }, async () => {
+        try {
+            const [rules, skills] = await Promise.all([source.listRules(), source.listSkills()]);
+            const structuredContent = { rules, skills, source: sourceInfo };
+            const lines = [
+                "## Rules",
+                rules.length ? rules.map((rule) => `- ${rule}`).join("\n") : "_none_",
+                "",
+                "## Skills",
+                skills.length
+                    ? skills.map((skill) => `- ${skill.name} — ${skill.description}`).join("\n")
+                    : "_none_",
+            ];
+            return {
+                content: [{ type: "text", text: lines.join("\n") }],
+                structuredContent,
+            };
+        }
+        catch (error) {
+            return toToolErrorResult(error);
+        }
+    });
+    // ─── get_rule ──────────────────────────────────────────────────────────────
+    server.registerTool("get_rule", {
+        title: "Get rule content",
+        description: "Get the content of a rule. Use a name from the `list` tool, e.g. 'mvi'.",
+        inputSchema: {
+            name: z.string().describe("Lowercase kebab-case rule name without the '.md' suffix, e.g. 'mvi-error-handling'"),
+        },
+        outputSchema: {
+            name: z.string(),
+            content: z.string(),
+            source: z.object(sourceOutputShape),
+        },
+        annotations: {
+            title: "Get rule content",
+            readOnlyHint,
+            openWorldHint,
+        },
+    }, async ({ name }) => {
+        try {
+            const validName = validateRuleName(name);
+            const content = await source.getRule(validName);
+            return {
+                content: [{ type: "text", text: content }],
+                structuredContent: { name: validName, content, source: sourceInfo },
+            };
+        }
+        catch (error) {
+            return toToolErrorResult(error);
+        }
+    });
+    // ─── get_skill ─────────────────────────────────────────────────────────────
+    server.registerTool("get_skill", {
+        title: "Get skill instructions",
+        description: "Get the instructions for a skill. Use a name from the `list` tool, e.g. 'create-feature-scaffold-screen'.",
+        inputSchema: {
+            name: z.string().describe("Skill name (kebab-case directory name), e.g. 'create-feature-scaffold-screen'"),
+        },
+        outputSchema: {
+            name: z.string(),
+            description: z.string(),
+            content: z.string(),
+            source: z.object(sourceOutputShape),
+        },
+        annotations: {
+            title: "Get skill instructions",
+            readOnlyHint,
+            openWorldHint,
+        },
+    }, async ({ name }) => {
+        try {
+            const validName = validateSkillName(name);
+            const skill = await source.getSkill(validName);
+            return {
+                content: [{ type: "text", text: skill.content }],
+                structuredContent: {
+                    name: validName,
+                    description: skill.description,
+                    content: skill.content,
+                    source: sourceInfo,
+                },
+            };
+        }
+        catch (error) {
+            return toToolErrorResult(error);
+        }
+    });
+    return server;
+}

package/dist/source/bundled.js

@@ -0,0 +1,78 @@
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { WorkflowError } from "../errors.js";
+import { parseFrontmatter } from "../frontmatter.js";
+/**
+ * Directory the npm package ships rules/skills in. `scripts/copy-assets.ts` populates this
+ * directory (from the repository's `rules/`/`skills/`) before every build/dev/test/pack, and
+ * `package.json#files` includes it, so this is what `npm pack`/`npm publish` embeds.
+ */
+function assetsDir() {
+    const moduleDir = dirname(fileURLToPath(import.meta.url));
+    return join(moduleDir, "..", "..", "assets");
+}
+/**
+ * Default WorkflowSource: reads the bundled npm-packaged snapshot from `mcp/assets`. Performs no
+ * network access whatsoever.
+ */
+export class BundledSource {
+    ref;
+    rulesDir;
+    skillsDir;
+    constructor(ref) {
+        this.ref = ref;
+        const base = assetsDir();
+        this.rulesDir = join(base, "rules");
+        this.skillsDir = join(base, "skills");
+    }
+    info() {
+        return { kind: "bundled", ref: this.ref };
+    }
+    async listRules() {
+        return readdirSync(this.rulesDir, { withFileTypes: true })
+            .filter((entry) => entry.isFile() && /^[a-z0-9]+(?:-[a-z0-9]+)*\.md$/.test(entry.name))
+            .map((entry) => entry.name.replace(/\.md$/, ""))
+            .sort();
+    }
+    async listSkills() {
+        const skillNames = readdirSync(this.skillsDir)
+            .filter((entry) => statSync(join(this.skillsDir, entry)).isDirectory())
+            .sort();
+        const summaries = [];
+        for (const name of skillNames) {
+            const skillMdPath = join(this.skillsDir, name, "SKILL.md");
+            try {
+                const raw = readFileSync(skillMdPath, "utf8");
+                const { fields } = parseFrontmatter(raw);
+                summaries.push({ name, description: fields.description ?? "" });
+            }
+            catch {
+                // A skill directory without a readable SKILL.md is not listed; get_skill will still
+                // surface NOT_FOUND if it's requested directly.
+            }
+        }
+        return summaries;
+    }
+    async getRule(name) {
+        const path = join(this.rulesDir, `${name}.md`);
+        try {
+            return readFileSync(path, "utf8");
+        }
+        catch {
+            throw new WorkflowError("NOT_FOUND", `Rule '${name}' was not found in the bundled snapshot.`);
+        }
+    }
+    async getSkill(name) {
+        const path = join(this.skillsDir, name, "SKILL.md");
+        let raw;
+        try {
+            raw = readFileSync(path, "utf8");
+        }
+        catch {
+            throw new WorkflowError("NOT_FOUND", `Skill '${name}' was not found in the bundled snapshot.`);
+        }
+        const { fields, body } = parseFrontmatter(raw);
+        return { description: fields.description ?? "", content: body.trim() };
+    }
+}

package/dist/source/cache.js

@@ -0,0 +1,61 @@
+/**
+ * A small bounded TTL cache used by the optional GitHub source.
+ *
+ * - `maxEntries` bounds memory: once exceeded, the oldest inserted entry is evicted (a bounded
+ *   Map, not an unbounded one).
+ * - `getStale` returns the last known value for a key even after it has expired, so callers can
+ *   fall back to it when a live GitHub fetch fails (network down, rate limited, etc).
+ */
+export class BoundedTtlCache {
+    options;
+    entries = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    get(key) {
+        const entry = this.entries.get(key);
+        if (!entry) {
+            return undefined;
+        }
+        if (entry.expiresAt < Date.now()) {
+            return undefined;
+        }
+        return entry.value;
+    }
+    getStale(key) {
+        return this.entries.get(key)?.value;
+    }
+    set(key, value) {
+        if (!this.entries.has(key) && this.entries.size >= this.options.maxEntries) {
+            const oldestKey = this.entries.keys().next().value;
+            if (oldestKey !== undefined) {
+                this.entries.delete(oldestKey);
+            }
+        }
+        // Re-inserting moves the key to the end of Map's iteration order, keeping "oldest first"
+        // eviction meaningful for entries that get refreshed often.
+        this.entries.delete(key);
+        this.entries.set(key, { value, expiresAt: Date.now() + this.options.ttlMs });
+    }
+    get size() {
+        return this.entries.size;
+    }
+}
+/**
+ * De-duplicates concurrent calls for the same key: if a call for `key` is already in flight, the
+ * caller gets the same in-flight promise instead of starting a second network request.
+ */
+export class RequestDeduplicator {
+    inFlight = new Map();
+    async run(key, fn) {
+        const existing = this.inFlight.get(key);
+        if (existing) {
+            return existing;
+        }
+        const promise = fn().finally(() => {
+            this.inFlight.delete(key);
+        });
+        this.inFlight.set(key, promise);
+        return promise;
+    }
+}

package/dist/source/github-source.js

@@ -0,0 +1,68 @@
+import { WorkflowError } from "../errors.js";
+import { parseFrontmatter } from "../frontmatter.js";
+import { GithubClient } from "./github.js";
+const OWNER = "michaelbel";
+const REPO = "cuckcoder";
+/**
+ * Optional remote WorkflowSource: reads rules/skills straight from GitHub at a pinned,
+ * validated ref (never `main`/`master`). Read-only, but network-dependent (`openWorldHint: true`
+ * on the tools that use it).
+ */
+export class GithubSource {
+    ref;
+    client;
+    constructor(ref, token, fetchImpl) {
+        this.ref = ref;
+        this.client = new GithubClient({ owner: OWNER, repo: REPO, token, fetchImpl });
+    }
+    info() {
+        return { kind: "github", ref: this.ref };
+    }
+    async listRules() {
+        const tree = await this.client.listTree(this.ref);
+        return tree
+            .filter((item) => item.type === "blob" && /^rules\/[a-z0-9]+(?:-[a-z0-9]+)*\.md$/.test(item.path))
+            .map((item) => item.path.replace(/^rules\//, "").replace(/\.md$/, ""))
+            .sort();
+    }
+    async listSkills() {
+        const tree = await this.client.listTree(this.ref);
+        const skillPaths = tree
+            .filter((item) => item.type === "blob" && /^skills\/[^/]+\/SKILL\.md$/.test(item.path))
+            .map((item) => item.path)
+            .sort();
+        const summaries = [];
+        for (const path of skillPaths) {
+            const name = path.replace(/^skills\//, "").replace(/\/SKILL\.md$/, "");
+            const raw = await this.client.fetchFile(this.ref, path);
+            const { fields } = parseFrontmatter(raw);
+            summaries.push({ name, description: fields.description ?? "" });
+        }
+        return summaries;
+    }
+    async getRule(name) {
+        try {
+            return await this.client.fetchFile(this.ref, `rules/${name}.md`);
+        }
+        catch (error) {
+            if (error instanceof WorkflowError && error.code === "NOT_FOUND") {
+                throw new WorkflowError("NOT_FOUND", `Rule '${name}' was not found at ref '${this.ref}'.`);
+            }
+            throw error;
+        }
+    }
+    async getSkill(name) {
+        let raw;
+        try {
+            raw = await this.client.fetchFile(this.ref, `skills/${name}/SKILL.md`);
+        }
+        catch (error) {
+            if (error instanceof WorkflowError && error.code === "NOT_FOUND") {
+                throw new WorkflowError("NOT_FOUND", `Skill '${name}' was not found at ref '${this.ref}'.`);
+            }
+            throw error;
+        }
+        const { fields, body } = parseFrontmatter(raw);
+        return { description: fields.description ?? "", content: body.trim() };
+    }
+}