@michaelbel/cuckcoder-mcp 1.6.12 → 1.6.14

package/dist/source/bundled.js

@@ -3,6 +3,7 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { WorkflowError } from "../errors.js";
 import { parseFrontmatter } from "../frontmatter.js";
+import { parseWorkflowMeta } from "../workflow-meta.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
@@ -20,11 +21,15 @@ export class BundledSource {
     ref;
     rulesDir;
     skillsDir;
+    agentsDir;
+    workflowsDir;
     constructor(ref) {
         this.ref = ref;
         const base = assetsDir();
         this.rulesDir = join(base, "rules");
         this.skillsDir = join(base, "skills");
+        this.agentsDir = join(base, "agents");
+        this.workflowsDir = join(base, "workflows");
     }
     info() {
         return { kind: "bundled", ref: this.ref };
@@ -75,4 +80,77 @@ export class BundledSource {
         const { fields, body } = parseFrontmatter(raw);
         return { description: fields.description ?? "", content: body.trim() };
     }
+    async listAgents() {
+        const names = readdirSync(this.agentsDir, { withFileTypes: true })
+            .filter((entry) => entry.isFile() && /^[a-z0-9]+(?:-[a-z0-9]+)*\.md$/.test(entry.name))
+            .map((entry) => entry.name.replace(/\.md$/, ""))
+            .sort();
+        const summaries = [];
+        for (const name of names) {
+            try {
+                const raw = readFileSync(join(this.agentsDir, `${name}.md`), "utf8");
+                const { fields } = parseFrontmatter(raw);
+                summaries.push({ name, description: fields.description ?? "" });
+            }
+            catch {
+                // An agent file without readable frontmatter is not listed; get_agent will still
+                // surface NOT_FOUND if it's requested directly.
+            }
+        }
+        return summaries;
+    }
+    async getAgent(name) {
+        const path = join(this.agentsDir, `${name}.md`);
+        let raw;
+        try {
+            raw = readFileSync(path, "utf8");
+        }
+        catch {
+            throw new WorkflowError("NOT_FOUND", `Agent '${name}' was not found in the bundled snapshot.`);
+        }
+        const { fields, body } = parseFrontmatter(raw);
+        return {
+            description: fields.description ?? "",
+            tools: fields.tools ?? "",
+            disallowedTools: fields.disallowedTools ?? "",
+            content: body.trim(),
+        };
+    }
+    async listWorkflows() {
+        const names = readdirSync(this.workflowsDir, { withFileTypes: true })
+            .filter((entry) => entry.isFile() && /^[a-z0-9]+(?:-[a-z0-9]+)*\.js$/.test(entry.name))
+            .map((entry) => entry.name.replace(/\.js$/, ""))
+            .sort();
+        const summaries = [];
+        for (const name of names) {
+            try {
+                const raw = readFileSync(join(this.workflowsDir, `${name}.js`), "utf8");
+                const meta = parseWorkflowMeta(raw);
+                summaries.push({ name, description: meta.description });
+            }
+            catch {
+                // A workflow file whose meta block can't be parsed is not listed; get_workflow will
+                // still surface an error if it's requested directly.
+            }
+        }
+        return summaries;
+    }
+    async getWorkflow(name) {
+        const path = join(this.workflowsDir, `${name}.js`);
+        let raw;
+        try {
+            raw = readFileSync(path, "utf8");
+        }
+        catch {
+            throw new WorkflowError("NOT_FOUND", `Workflow '${name}' was not found in the bundled snapshot.`);
+        }
+        let meta;
+        try {
+            meta = parseWorkflowMeta(raw);
+        }
+        catch (error) {
+            throw new WorkflowError("INTERNAL_ERROR", `Workflow '${name}' has an unparsable meta block: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return { description: meta.description, whenToUse: meta.whenToUse, content: raw };
+    }
 }

package/dist/source/github-source.js

@@ -1,5 +1,6 @@
 import { WorkflowError } from "../errors.js";
 import { parseFrontmatter } from "../frontmatter.js";
+import { parseWorkflowMeta } from "../workflow-meta.js";
 import { GithubClient } from "./github.js";
 const OWNER = "michaelbel";
 const REPO = "cuckcoder";
@@ -65,4 +66,79 @@ export class GithubSource {
         const { fields, body } = parseFrontmatter(raw);
         return { description: fields.description ?? "", content: body.trim() };
     }
+    async listAgents() {
+        const tree = await this.client.listTree(this.ref);
+        const paths = tree
+            .filter((item) => item.type === "blob" && /^agents\/[a-z0-9]+(?:-[a-z0-9]+)*\.md$/.test(item.path))
+            .map((item) => item.path)
+            .sort();
+        const summaries = [];
+        for (const path of paths) {
+            const name = path.replace(/^agents\//, "").replace(/\.md$/, "");
+            const raw = await this.client.fetchFile(this.ref, path);
+            const { fields } = parseFrontmatter(raw);
+            summaries.push({ name, description: fields.description ?? "" });
+        }
+        return summaries;
+    }
+    async getAgent(name) {
+        let raw;
+        try {
+            raw = await this.client.fetchFile(this.ref, `agents/${name}.md`);
+        }
+        catch (error) {
+            if (error instanceof WorkflowError && error.code === "NOT_FOUND") {
+                throw new WorkflowError("NOT_FOUND", `Agent '${name}' was not found at ref '${this.ref}'.`);
+            }
+            throw error;
+        }
+        const { fields, body } = parseFrontmatter(raw);
+        return {
+            description: fields.description ?? "",
+            tools: fields.tools ?? "",
+            disallowedTools: fields.disallowedTools ?? "",
+            content: body.trim(),
+        };
+    }
+    async listWorkflows() {
+        const tree = await this.client.listTree(this.ref);
+        const paths = tree
+            .filter((item) => item.type === "blob" && /^workflows\/[a-z0-9]+(?:-[a-z0-9]+)*\.js$/.test(item.path))
+            .map((item) => item.path)
+            .sort();
+        const summaries = [];
+        for (const path of paths) {
+            const name = path.replace(/^workflows\//, "").replace(/\.js$/, "");
+            const raw = await this.client.fetchFile(this.ref, path);
+            try {
+                const meta = parseWorkflowMeta(raw);
+                summaries.push({ name, description: meta.description });
+            }
+            catch {
+                // A workflow file whose meta block can't be parsed is not listed; get_workflow will
+                // still surface an error if it's requested directly.
+            }
+        }
+        return summaries;
+    }
+    async getWorkflow(name) {
+        let raw;
+        try {
+            raw = await this.client.fetchFile(this.ref, `workflows/${name}.js`);
+        }
+        catch (error) {
+            if (error instanceof WorkflowError && error.code === "NOT_FOUND") {
+                throw new WorkflowError("NOT_FOUND", `Workflow '${name}' was not found at ref '${this.ref}'.`);
+            }
+            throw error;
+        }
+        let meta;
+        try {
+            meta = parseWorkflowMeta(raw);
+        }
+        catch (error) {
+            throw new WorkflowError("INTERNAL_ERROR", `Workflow '${name}' has an unparsable meta block: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return { description: meta.description, whenToUse: meta.whenToUse, content: raw };
+    }
 }

package/dist/validation.js

@@ -31,3 +31,19 @@ export function validateRuleName(rawName) {
     }
     return rawName;
 }
+/** Agent name: the lowercase kebab-case basename without `.md`, e.g. `kotlin-engineer`. */
+const AGENT_NAME_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+export function validateAgentName(rawName) {
+    if (!AGENT_NAME_PATTERN.test(rawName)) {
+        throw new WorkflowError("INVALID_NAME", `Invalid agent name '${rawName}'. Expected a lowercase kebab-case agent name, e.g. 'kotlin-engineer'.`);
+    }
+    return rawName;
+}
+/** Workflow name: the lowercase kebab-case basename without `.js`, e.g. `full-review`. */
+const WORKFLOW_NAME_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+export function validateWorkflowName(rawName) {
+    if (!WORKFLOW_NAME_PATTERN.test(rawName)) {
+        throw new WorkflowError("INVALID_NAME", `Invalid workflow name '${rawName}'. Expected a lowercase kebab-case workflow name, e.g. 'full-review'.`);
+    }
+    return rawName;
+}

package/dist/workflow-meta.js

@@ -0,0 +1,29 @@
+const META_BLOCK_PATTERN = /export\s+const\s+meta\s*=\s*(\{[\s\S]*?\n\})/;
+/**
+ * Extracts `export const meta = { name, description, whenToUse? }` from a workflow module's
+ * source text without importing the module. Workflow files reference sweep-runtime globals
+ * (`args`, `agent`, `phase`, ...) at the top level, so `import()`-ing one directly would throw;
+ * this only evaluates the isolated `meta` object literal, which in every workflow is just string
+ * literals joined with `+`.
+ */
+export function parseWorkflowMeta(source) {
+    const match = source.match(META_BLOCK_PATTERN);
+    if (!match) {
+        throw new Error("no 'export const meta = {...}' block found");
+    }
+    let meta;
+    try {
+        meta = new Function(`"use strict"; return (${match[1]});`)();
+    }
+    catch (error) {
+        throw new Error(`failed to evaluate the workflow meta block: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (typeof meta !== "object" ||
+        meta === null ||
+        typeof meta.name !== "string" ||
+        typeof meta.description !== "string") {
+        throw new Error("workflow meta block did not evaluate to { name: string, description: string, ... }");
+    }
+    const { name, description, whenToUse } = meta;
+    return { name, description, whenToUse: typeof whenToUse === "string" ? whenToUse : "" };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@michaelbel/cuckcoder-mcp",
-  "version": "1.6.12",
+  "version": "1.6.14",
   "description": "MCP server for Cuckcoder rules and skills",
   "type": "module",
   "main": "dist/index.js",

package/assets/rules/app-badging.md

@@ -1,170 +0,0 @@
----
-description: >-
-  Регресс-гард доступности устройств: aapt2 dump badging в golden-файл app/badging, обязательный
-  check<Variant>Badging в CI, необязательное железо через android:required=false
-paths:
-  - "**/*.gradle.kts"
-  - "**/AndroidManifest.xml"
----
-
-`aapt2 dump badging` по собранному APK показывает эффективный набор `uses-feature` /
-`uses-permission` / `uses-sdk` — то, из-за чего Google Play скрывает приложение на планшетах,
-Android TV, Wear OS, складных устройствах и авто. Обновление зависимости может молча добавить
-`android:required` hardware feature (камера, телефония, автофокус) и срезать доступность, а в
-диффе исходников этого не видно. Гард фиксирует бейдж в golden-файл и валит CI при расхождении.
-
-## Что заводится в проекте
-
-- Convention-плагин `build-logic/`, который на каждый application-вариант регистрирует три задачи:
-  - `generate<Variant>Badging` — `aapt2 dump badging` по универсальному APK варианта → генерируемый
-    файл в `build/`.
-  - `update<Variant>Badging` — копирует генерируемый файл в golden `app/badging/<variant>.txt`
-    (запускается локально, результат коммитится и проходит ревью).
-  - `check<Variant>Badging` — сравнивает генерируемый с golden; при расхождении фейлит с диффом.
-- Golden-файлы `app/badging/*.txt` — под контролем версий; изменение бейджа всегда осознанное и
-  видно в PR.
-
-## Правила
-
-- `check<Variant>Badging` (как минимум для release-варианта) — обязательный шаг CI на каждый PR.
-- Изменение `app/badging/*.txt` в PR без соответствующей причины (новая фича, осознанное
-  требование к железу) — стоп-фактор ревью.
-- Все `uses-feature` для необязательного железа объявляй с `android:required="false"`; жёсткое
-  требование железа — только когда приложение без него нефункционально.
-- Не добавляй `check*Badging` в `dependsOn` обычной сборки — это отдельный verification-шаг, чтобы
-  не замедлять локальный цикл.
-
-## Скелет convention-плагина
-
-```kotlin
-// build-logic/convention/src/main/kotlin/AndroidApplicationBadgingConventionPlugin.kt
-import com.android.build.api.artifact.SingleArtifact
-import com.android.build.api.variant.ApplicationAndroidComponentsExtension
-import org.gradle.api.DefaultTask
-import org.gradle.api.Plugin
-import org.gradle.api.Project
-import org.gradle.api.file.RegularFileProperty
-import org.gradle.api.provider.Property
-import org.gradle.api.tasks.CacheableTask
-import org.gradle.api.tasks.Copy
-import org.gradle.api.tasks.InputFile
-import org.gradle.api.tasks.OutputFile
-import org.gradle.api.tasks.PathSensitive
-import org.gradle.api.tasks.PathSensitivity
-import org.gradle.api.tasks.TaskAction
-import org.gradle.kotlin.dsl.register
-
-class AndroidApplicationBadgingConventionPlugin : Plugin<Project> {
-    override fun apply(target: Project) {
-        val components = target.extensions
-            .getByType(ApplicationAndroidComponentsExtension::class.java)
-
-        components.onVariants { variant ->
-            val capitalised = variant.name.replaceFirstChar { it.uppercaseChar() }
-            val golden = target.rootDir.resolve("app/badging/${variant.name}.txt")
-            val generated = target.layout.buildDirectory.file("badging/${variant.name}.txt")
-            val apk = variant.artifacts.get(SingleArtifact.APK)
-
-            val generate = target.tasks.register<GenerateBadgingTask>("generate${capitalised}Badging") {
-                apkDir.set(apk)
-                aapt2.set(resolveAapt2(target))
-                output.set(generated)
-            }
-
-            target.tasks.register<Copy>("update${capitalised}Badging") {
-                group = "badging"
-                description = "Обновляет app/badging/${variant.name}.txt — закоммить результат"
-                dependsOn(generate)
-                from(generated)
-                into(golden.parentFile.also { it.mkdirs() })
-                rename { golden.name }
-            }
-
-            target.tasks.register<CheckBadgingTask>("check${capitalised}Badging") {
-                group = "verification"
-                description = "Фейлит, если требуемые фичи ${variant.name}-APK разошлись с golden-файлом"
-                dependsOn(generate)
-                generated.set(generated)
-                this.golden.set(golden)
-            }
-        }
-    }
-}
-
-@CacheableTask
-abstract class GenerateBadgingTask : DefaultTask() {
-    @get:InputFile @get:PathSensitive(PathSensitivity.NONE)
-    abstract val apkDir: RegularFileProperty
-
-    @get:org.gradle.api.tasks.Input
-    abstract val aapt2: Property<String>
-
-    @get:OutputFile
-    abstract val output: RegularFileProperty
-
-    @TaskAction
-    fun run() {
-        val apk = apkDir.get().asFile.parentFile
-            .listFiles { f -> f.extension == "apk" }?.firstOrNull()
-            ?: error("APK не найден в ${apkDir.get().asFile.parentFile}")
-        val out = output.get().asFile.also { it.parentFile.mkdirs() }
-        project.exec {
-            commandLine(aapt2.get(), "dump", "badging", apk.absolutePath)
-            standardOutput = out.outputStream()
-        }
-    }
-}
-
-@CacheableTask
-abstract class CheckBadgingTask : DefaultTask() {
-    @get:InputFile @get:PathSensitive(PathSensitivity.RELATIVE)
-    abstract val generated: RegularFileProperty
-
-    @get:InputFile @get:PathSensitive(PathSensitivity.RELATIVE)
-    abstract val golden: RegularFileProperty
-
-    @TaskAction
-    fun run() {
-        val g = generated.get().asFile.readText()
-        val expected = golden.get().asFile.let {
-            if (!it.exists()) error("Нет golden-файла ${it.path} — запусти update…Badging и закоммить")
-            it.readText()
-        }
-        if (g.trim() != expected.trim()) {
-            error(
-                "Бейдж APK разошёлся с golden-файлом ${golden.get().asFile.path}.\n" +
-                    "Если изменение осознанное — запусти ./gradlew update…Badging и закоммить новый golden."
-            )
-        }
-    }
-}
-
-private fun resolveAapt2(project: Project): String {
-    val android = project.extensions
-        .getByType(com.android.build.gradle.BaseExtension::class.java)
-    return android.sdkDirectory
-        .resolve("build-tools/${android.buildToolsVersion}/aapt2")
-        .absolutePath
-}
-```
-
-## CI
-
-```yaml
-# .github/workflows/pr-check.yml (фрагмент)
-      - name: App badging check
-        run: ./gradlew checkReleaseBadging
-```
-
-## Как выглядит golden-файл
-
-```
-# app/badging/release.txt
-package: name='com.example.app' versionCode='142' versionName='1.4.2'
-sdkVersion:'26'
-targetSdkVersion:'35'
-uses-permission: name='android.permission.INTERNET'
-uses-feature-not-required: name='android.hardware.camera'
-feature-group: label=''
-  uses-feature: name='android.hardware.faketouch'
-```