@michaelbel/cuckcoder-mcp 1.6.12 → 1.6.14

package/assets/workflows/refactoring-sweep.js

@@ -0,0 +1,199 @@
+export const meta = {
+  name: 'refactoring-sweep',
+  description:
+    'Аудит → triage → (опционально) применение рефакторинга по проекту: параллельный ' +
+    'аудит линзами архитектуры/упрощения/безопасности/производительности, затем ' +
+    'применение одобренных фиксов в изолированных worktree по платформам и ' +
+    'валидация сборки.',
+  whenToUse: 'Крупный рефакторинг или чистка — рефакторинг, почисти код, убери дублирование.',
+}
+
+// ── args ────────────────────────────────────────────────────────────────
+//   request        : что рефакторить / область фокуса (может быть пустым —
+//                     "весь проект")
+//   mode           : 'audit-only' (по умолчанию) | 'apply'
+//   severityFilter : 'all' | 'critical+high' (по умолчанию) | 'critical-only' —
+//                     какие находки чинит mode='apply'
+const A = typeof args === 'string' ? JSON.parse(args) || {} : args || {}
+const REQUEST = A.request || 'общая чистка кода'
+const MODE = A.mode || 'audit-only'
+const SEVERITY_FILTER = A.severityFilter || 'critical+high'
+
+const FINDING_SCHEMA = {
+  type: 'object',
+  required: ['file', 'issue', 'severity', 'fix'],
+  properties: {
+    file: { type: 'string' },
+    line: { type: 'string' },
+    issue: { type: 'string' },
+    severity: { type: 'string', enum: ['critical', 'high', 'medium', 'low'] },
+    fix: { type: 'string' },
+  },
+}
+
+phase('Audit')
+const lenses = [
+  {
+    role: 'architecture',
+    agentType: 'cuckcoder:architect-auditor',
+    focus:
+      'границы слоёв, направление зависимостей, связность, единственная ' +
+      'ответственность, публичные контракты',
+  },
+  {
+    role: 'simplification',
+    agentType: 'cuckcoder:code-refine',
+    focus:
+      'мёртвый код, дублирование, лишняя вложенность или абстракция, ' +
+      'переусложнённый control flow — только отчёт, не применяй пока',
+  },
+  {
+    role: 'security',
+    agentType: 'cuckcoder:security-auditor',
+    focus:
+      'захардкоженные секреты, отсутствующая авторизация, небезопасная ' +
+      'обработка ввода, небезопасные значения по умолчанию',
+  },
+  {
+    role: 'performance',
+    agentType: 'cuckcoder:performance-reviewer',
+    focus:
+      'лишняя рекомпозиция, блокирующая main thread работа, N+1-запросы, ' +
+      'неограниченный рост памяти',
+  },
+]
+
+const perLens = await parallel(
+  lenses.map((l) => () =>
+    agent(
+      `Аудит рефакторинга. Область фокуса: "${REQUEST}". Твоя линза — ${l.role}:
+       ${l.focus}. Читай реальный код. Указывай только конкретно проверяемые
+       находки, каждая с file, line если известна, issue, severity и
+       минимальным fix. Если проблем нет, верни пустой массив.`,
+      {
+        label: `audit:${l.role}`,
+        phase: 'Audit',
+        agentType: l.agentType,
+        schema: {
+          type: 'object',
+          required: ['findings'],
+          properties: { findings: { type: 'array', items: FINDING_SCHEMA } },
+        },
+      },
+    ).then((result) => (result ? result.findings.map((f) => ({ role: l.role, ...f })) : [])),
+  ),
+)
+
+const allFindings = perLens.flat()
+
+phase('Triage')
+const triage = await agent(
+  `Сгруппируй эти находки рефакторинга по severity и дедуплицируй
+   пересекающиеся (один и тот же file+issue от нескольких линз — объедини,
+   оставь максимальный severity, перечисли все линзы-источники):
+
+   ${JSON.stringify(allFindings, null, 2)}
+
+   Severity-фильтр для одобренного плана: "${SEVERITY_FILTER}" ("all" — всё,
+   "critical+high" — только critical и high, "critical-only" — только
+   critical). Верни counts по severity и approvedPlan — находки, прошедшие
+   фильтр.`,
+  {
+    label: 'triage',
+    phase: 'Triage',
+    schema: {
+      type: 'object',
+      required: ['counts', 'approvedPlan'],
+      properties: {
+        counts: {
+          type: 'object',
+          properties: {
+            critical: { type: 'number' },
+            high: { type: 'number' },
+            medium: { type: 'number' },
+            low: { type: 'number' },
+          },
+        },
+        approvedPlan: { type: 'array', items: FINDING_SCHEMA },
+      },
+    },
+  },
+)
+
+if (MODE === 'audit-only' || !triage.approvedPlan || triage.approvedPlan.length === 0) {
+  return { status: 'audited', counts: triage.counts, approvedPlan: triage.approvedPlan || [] }
+}
+
+phase('Execute')
+const isCompose = (f) => /\.kt$/.test(f) && /(screen|composable|compose|ui\/)/i.test(f)
+const isSwiftUI = (f) => /\.swift$/.test(f) && /(view|screen)/i.test(f)
+const isSwift = (f) => /\.swift$/.test(f) && !isSwiftUI(f)
+const isKotlin = (f) => /\.kt(s)?$/.test(f) && !isCompose(f)
+
+const layers = [
+  { name: 'kotlin', agentType: 'cuckcoder:kotlin-engineer', match: isKotlin },
+  { name: 'compose', agentType: 'cuckcoder:compose-builder', match: isCompose },
+  { name: 'swift', agentType: 'cuckcoder:swift-engineer', match: isSwift },
+  { name: 'swiftui', agentType: 'cuckcoder:swiftui-builder', match: isSwiftUI },
+]
+  .map((layer) => ({
+    ...layer,
+    plan: triage.approvedPlan.filter((f) => layer.match(f.file || '')),
+  }))
+  .filter((layer) => layer.plan.length > 0)
+
+const execResults = await parallel(
+  layers.map((layer) => () =>
+    agent(
+      `Примени ровно этот одобренный план рефакторинга и ничего сверх него —
+       никаких попутных улучшений, не трогай файлы вне этого списка:
+
+       ${JSON.stringify(layer.plan, null, 2)}
+
+       Сохраняй публичный API, если план явно не говорит иное. Не ломай
+       существующие тесты. Следуй конвенциям и правилам этого проекта.
+       Верни список изменённых файлов и краткое summary изменений и причин.`,
+      {
+        label: `execute:${layer.name}`,
+        phase: 'Execute',
+        agentType: layer.agentType,
+        isolation: 'worktree',
+        schema: {
+          type: 'object',
+          required: ['changedFiles', 'summary'],
+          properties: {
+            changedFiles: { type: 'array', items: { type: 'string' } },
+            summary: { type: 'string' },
+          },
+        },
+      },
+    ),
+  ),
+)
+
+phase('Validate')
+const changedFiles = execResults.filter(Boolean).flatMap((r) => r.changedFiles || [])
+const validation = await agent(
+  `Провалидируй этот рефакторинг. Изменённые файлы: ${JSON.stringify(changedFiles)}.
+   Собери проект и запусти его тесты (найди build-инструмент: gradlew,
+   swift build и т.п.). Верни passed (boolean) и details (что запускал
+   и результат).`,
+  {
+    label: 'validate',
+    phase: 'Validate',
+    agentType: 'cuckcoder:build-engineer',
+    schema: {
+      type: 'object',
+      required: ['passed', 'details'],
+      properties: { passed: { type: 'boolean' }, details: { type: 'string' } },
+    },
+  },
+)
+
+return {
+  status: validation && validation.passed ? 'refactored' : 'refactored-with-issues',
+  counts: triage.counts,
+  execResults: execResults.filter(Boolean),
+  changedFiles,
+  validation,
+}

package/assets/workflows/security-sweep.js

@@ -0,0 +1,98 @@
+export const meta = {
+  name: 'security-sweep',
+  description:
+    'Параллельный security-аудит по каждому модулю проекта с независимой проверкой ' +
+    'каждой находки перед итоговой выдачей.',
+}
+
+const discovery = await agent(
+  `Перечисли каждый модуль верхнего уровня или feature-пакет в этом проекте,
+   содержащий прикладной код, который стоит проверить отдельно (Gradle-модули,
+   KMP source set-ы или feature-пакеты вида shared/data/feature/<name> и
+   androidApp/feature/<name>). Верни пути относительно корня репозитория —
+   без build-вывода, сгенерированного кода и сторонних зависимостей.`,
+  {
+    schema: {
+      type: 'object',
+      required: ['modules'],
+      properties: { modules: { type: 'array', items: { type: 'string' } } },
+    },
+  },
+)
+
+const perModule = await pipeline(discovery.modules, (module) =>
+  agent(
+    `Ты старший application security engineer, проводящий read-only аудит
+     только модуля "${module}". Сначала построй краткую threat model (активы,
+     актёры, границы доверия), затем проверь аутентификацию, авторизацию,
+     секреты, криптографию, границы ввода/вывода, конфигурацию платформы
+     (манифест, exported-компоненты, permissions), transport security и
+     риски supply chain. Указывай только находки с конкретным эксплуатируемым
+     attack path и предусловиями — без общих советов по hardening. Если
+     находок нет, верни пустой массив.`,
+    {
+      label: module,
+      schema: {
+        type: 'object',
+        required: ['findings'],
+        properties: {
+          findings: {
+            type: 'array',
+            items: {
+              type: 'object',
+              required: ['severity', 'location', 'summary', 'attackPath', 'fix'],
+              properties: {
+                severity: { type: 'string' },
+                location: { type: 'string' },
+                summary: { type: 'string' },
+                attackPath: { type: 'string' },
+                impact: { type: 'string' },
+                fix: { type: 'string' },
+                validation: { type: 'string' },
+              },
+            },
+          },
+        },
+      },
+    },
+  ).then((result) => (result ? result.findings : [])),
+)
+
+const candidates = perModule.flat()
+
+const verified = await pipeline(candidates, (finding) =>
+  agent(
+    `Независимо проверь эту заявленную security-находку — перечитай код сам,
+     не доверяя исходному описанию. Подтверди, реален и достижим ли
+     attack path с учётом фактических проверок авторизации, валидации
+     ввода и конфигурации платформы.
+
+     Заявленная находка:
+     ${JSON.stringify(finding, null, 2)}
+
+     Верни те же поля плюс "confirmed" (boolean) и "confidence"
+     (50, 75 или 100). Если находка не подтвердилась, установи
+     confirmed: false и объясни причину в поле "reason".`,
+    {
+      label: finding.location,
+      schema: {
+        type: 'object',
+        required: ['confirmed', 'confidence'],
+        properties: {
+          confirmed: { type: 'boolean' },
+          confidence: { type: 'number' },
+          reason: { type: 'string' },
+          severity: { type: 'string' },
+          location: { type: 'string' },
+          summary: { type: 'string' },
+          attackPath: { type: 'string' },
+          impact: { type: 'string' },
+          fix: { type: 'string' },
+          validation: { type: 'string' },
+        },
+      },
+    },
+  ),
+)
+
+return verified.filter((finding) => finding?.confirmed)

package/assets/workflows/task-batch-create.js

@@ -0,0 +1,104 @@
+export const meta = {
+  name: 'task-batch-create',
+  description:
+    'Декомпозирует фичу или эпик на отдельные задачи и создаёт их все параллельно ' +
+    'в GitHub Issues или Notion — для одиночной задачи проще обратиться к агенту ' +
+    'трекера напрямую.',
+  whenToUse:
+    'Разбивка фичи/эпика на много задач сразу — заведи задачи, разбей на таски ' +
+    'и создай.',
+}
+
+// ── args ────────────────────────────────────────────────────────────────
+//   request  : описание фичи/эпика для декомпозиции (обязателен)
+//   platform : 'github' (по умолчанию) | 'notion'
+//   target   : "owner/repo" для GitHub, либо имя/id базы Notion — обязателен
+const A = typeof args === 'string' ? JSON.parse(args) || {} : args || {}
+const REQUEST = A.request || ''
+const PLATFORM = A.platform || 'github'
+const TARGET = A.target || ''
+
+if (!REQUEST || !TARGET) {
+  return {
+    status: 'skipped',
+    reason: 'Нужны и "request", и "target" (репозиторий или база Notion).',
+  }
+}
+
+phase('Decompose')
+const decomposition = await agent(
+  `Разбей эту фичу/эпик на отдельные, независимо выполнимые задачи:
+
+   "${REQUEST}"
+
+   Для каждой задачи нужно: title (в повелительном наклонении, например
+   "Добавить X", "Исправить Y"), type (bug/feature/improvement/task),
+   description (2-4 предложения), acceptanceCriteria (минимум 2 конкретных
+   критерия) и labels. Дели по естественным границам (слой, экран,
+   endpoint) — не создавай задачи меньше чем на полдня работы и не
+   объединяй несвязанные вещи в одну задачу.`,
+  {
+    label: 'decompose',
+    phase: 'Decompose',
+    schema: {
+      type: 'object',
+      required: ['tasks'],
+      properties: {
+        tasks: {
+          type: 'array',
+          items: {
+            type: 'object',
+            required: ['title', 'type', 'description', 'acceptanceCriteria', 'labels'],
+            properties: {
+              title: { type: 'string' },
+              type: { type: 'string', enum: ['bug', 'feature', 'improvement', 'task'] },
+              description: { type: 'string' },
+              acceptanceCriteria: { type: 'array', items: { type: 'string' } },
+              labels: { type: 'array', items: { type: 'string' } },
+            },
+          },
+        },
+      },
+    },
+  },
+)
+
+const tasks = (decomposition && decomposition.tasks) || []
+if (tasks.length === 0) {
+  return { status: 'no-tasks', request: REQUEST }
+}
+
+phase('Create')
+const agentType = PLATFORM === 'notion'
+  ? 'cuckcoder:notion-project-manager'
+  : 'cuckcoder:github-project-manager'
+
+const created = await pipeline(tasks, (task) =>
+  agent(
+    `Создай ровно один ${PLATFORM === 'notion' ? 'таск в Notion' : 'GitHub Issue'}
+     в "${TARGET}" для этой задачи, части более крупного эпика "${REQUEST}":
+
+     ${JSON.stringify(task, null, 2)}
+
+     Тело/описание должно включать acceptance criteria как чек-лист.
+     Не создавай никаких других issue и не изменяй существующие. Верни
+     url и id созданного элемента.`,
+    {
+      label: task.title,
+      phase: 'Create',
+      agentType,
+      schema: {
+        type: 'object',
+        required: ['url', 'id'],
+        properties: { url: { type: 'string' }, id: { type: 'string' } },
+      },
+    },
+  ).then((result) => ({ title: task.title, ...result })),
+)
+
+return {
+  status: 'created',
+  platform: PLATFORM,
+  target: TARGET,
+  tasks: created,
+}

package/dist/search.js

@@ -0,0 +1,38 @@
+const SNIPPET_RADIUS = 80;
+function buildSnippet(content, query) {
+    const index = content.toLowerCase().indexOf(query.toLowerCase());
+    if (index === -1) {
+        return content.slice(0, SNIPPET_RADIUS * 2).trim();
+    }
+    const start = Math.max(0, index - SNIPPET_RADIUS);
+    const end = Math.min(content.length, index + query.length + SNIPPET_RADIUS);
+    const prefix = start > 0 ? "…" : "";
+    const suffix = end < content.length ? "…" : "";
+    return `${prefix}${content.slice(start, end).trim()}${suffix}`;
+}
+/**
+ * Rough case-insensitive keyword search across every rule and skill's full content (and, for
+ * skills, their description). Fetches every item from `source` — cheap for the bundled source
+ * (local reads), and no worse than a caller looping `get_rule`/`get_skill` themselves for the
+ * GitHub source, which caches/dedupes per-file fetches already.
+ */
+export async function searchRulesAndSkills(source, query) {
+    const needle = query.toLowerCase();
+    const results = [];
+    const [ruleNames, skills] = await Promise.all([source.listRules(), source.listSkills()]);
+    await Promise.all(ruleNames.map(async (name) => {
+        const content = await source.getRule(name);
+        if (content.toLowerCase().includes(needle) || name.toLowerCase().includes(needle)) {
+            results.push({ type: "rule", name, snippet: buildSnippet(content, query) });
+        }
+    }));
+    await Promise.all(skills.map(async (skill) => {
+        const { description, content } = await source.getSkill(skill.name);
+        const haystack = `${skill.name}\n${description}\n${content}`;
+        if (haystack.toLowerCase().includes(needle)) {
+            results.push({ type: "skill", name: skill.name, snippet: buildSnippet(`${description}\n\n${content}`, query) });
+        }
+    }));
+    results.sort((a, b) => (a.type === b.type ? a.name.localeCompare(b.name) : a.type.localeCompare(b.type)));
+    return results;
+}

package/dist/server.js

@@ -1,13 +1,15 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
 import { toToolErrorResult } from "./errors.js";
+import { searchRulesAndSkills } from "./search.js";
 import { createSource } from "./source/index.js";
-import { validateRuleName, validateSkillName } from "./validation.js";
+import { validateAgentName, validateRuleName, validateSkillName, validateWorkflowName } 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.",
+    "Use this server as the source of truth for Cuckcoder rules, skills, agents, and workflows.",
     "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.",
+    "Use search to find relevant rules/skills by keyword instead of guessing names.",
 ].join("\n");
 const sourceOutputShape = {
     kind: z.enum(["bundled", "github"]),
@@ -127,5 +129,162 @@ export function createServer(options = {}) {
             return toToolErrorResult(error);
         }
     });
+    // ─── list_agents ───────────────────────────────────────────────────────────
+    server.registerTool("list_agents", {
+        title: "List agents",
+        description: "List all available sub-agent names and descriptions in the Cuckcoder repository.",
+        inputSchema: {},
+        outputSchema: {
+            agents: z.array(z.object({ name: z.string(), description: z.string() })),
+            source: z.object(sourceOutputShape),
+        },
+        annotations: {
+            title: "List agents",
+            readOnlyHint,
+            openWorldHint,
+        },
+    }, async () => {
+        try {
+            const agents = await source.listAgents();
+            const structuredContent = { agents, source: sourceInfo };
+            const lines = agents.length
+                ? agents.map((agent) => `- ${agent.name} — ${agent.description}`).join("\n")
+                : "_none_";
+            return {
+                content: [{ type: "text", text: lines }],
+                structuredContent,
+            };
+        }
+        catch (error) {
+            return toToolErrorResult(error);
+        }
+    });
+    // ─── get_agent ─────────────────────────────────────────────────────────────
+    server.registerTool("get_agent", {
+        title: "Get agent definition",
+        description: "Get the role, tools, and full definition of a sub-agent. Use a name from `list_agents`, e.g. 'kotlin-engineer'.",
+        inputSchema: {
+            name: z.string().describe("Lowercase kebab-case agent name, e.g. 'kotlin-engineer'"),
+        },
+        outputSchema: {
+            name: z.string(),
+            description: z.string(),
+            tools: z.string(),
+            disallowedTools: z.string(),
+            content: z.string(),
+            source: z.object(sourceOutputShape),
+        },
+        annotations: {
+            title: "Get agent definition",
+            readOnlyHint,
+            openWorldHint,
+        },
+    }, async ({ name }) => {
+        try {
+            const validName = validateAgentName(name);
+            const agent = await source.getAgent(validName);
+            return {
+                content: [{ type: "text", text: agent.content }],
+                structuredContent: { name: validName, ...agent, source: sourceInfo },
+            };
+        }
+        catch (error) {
+            return toToolErrorResult(error);
+        }
+    });
+    // ─── list_workflows ────────────────────────────────────────────────────────
+    server.registerTool("list_workflows", {
+        title: "List workflows",
+        description: "List all available workflow (sweep pipeline) names and descriptions in the Cuckcoder repository.",
+        inputSchema: {},
+        outputSchema: {
+            workflows: z.array(z.object({ name: z.string(), description: z.string() })),
+            source: z.object(sourceOutputShape),
+        },
+        annotations: {
+            title: "List workflows",
+            readOnlyHint,
+            openWorldHint,
+        },
+    }, async () => {
+        try {
+            const workflows = await source.listWorkflows();
+            const structuredContent = { workflows, source: sourceInfo };
+            const lines = workflows.length
+                ? workflows.map((workflow) => `- ${workflow.name} — ${workflow.description}`).join("\n")
+                : "_none_";
+            return {
+                content: [{ type: "text", text: lines }],
+                structuredContent,
+            };
+        }
+        catch (error) {
+            return toToolErrorResult(error);
+        }
+    });
+    // ─── get_workflow ──────────────────────────────────────────────────────────
+    server.registerTool("get_workflow", {
+        title: "Get workflow source",
+        description: "Get the description, when-to-use, and full source of a workflow. Use a name from `list_workflows`, e.g. 'full-review'.",
+        inputSchema: {
+            name: z.string().describe("Lowercase kebab-case workflow name, e.g. 'full-review'"),
+        },
+        outputSchema: {
+            name: z.string(),
+            description: z.string(),
+            whenToUse: z.string(),
+            content: z.string(),
+            source: z.object(sourceOutputShape),
+        },
+        annotations: {
+            title: "Get workflow source",
+            readOnlyHint,
+            openWorldHint,
+        },
+    }, async ({ name }) => {
+        try {
+            const validName = validateWorkflowName(name);
+            const workflow = await source.getWorkflow(validName);
+            return {
+                content: [{ type: "text", text: workflow.content }],
+                structuredContent: { name: validName, ...workflow, source: sourceInfo },
+            };
+        }
+        catch (error) {
+            return toToolErrorResult(error);
+        }
+    });
+    // ─── search ────────────────────────────────────────────────────────────────
+    server.registerTool("search", {
+        title: "Search rules and skills",
+        description: "Rough case-insensitive keyword search across every rule's and skill's full content. Use instead of guessing a rule/skill name.",
+        inputSchema: {
+            query: z.string().min(1).describe("Keyword or phrase to search for, e.g. 'coroutine scope'"),
+        },
+        outputSchema: {
+            results: z.array(z.object({ type: z.enum(["rule", "skill"]), name: z.string(), snippet: z.string() })),
+            source: z.object(sourceOutputShape),
+        },
+        annotations: {
+            title: "Search rules and skills",
+            readOnlyHint,
+            openWorldHint,
+        },
+    }, async ({ query }) => {
+        try {
+            const results = await searchRulesAndSkills(source, query);
+            const structuredContent = { results, source: sourceInfo };
+            const lines = results.length
+                ? results.map((result) => `- [${result.type}] ${result.name}: ${result.snippet}`).join("\n")
+                : "_no matches_";
+            return {
+                content: [{ type: "text", text: lines }],
+                structuredContent,
+            };
+        }
+        catch (error) {
+            return toToolErrorResult(error);
+        }
+    });
     return server;
 }