@groupby/ai-dev 0.1.1 → 0.2.0

package/README.md

@@ -88,6 +88,15 @@ npm run build
 # Output is in dist/
 ```
 
+### Running tests
+
+```sh
+npm test           # Run all tests once
+npm run test:watch # Watch mode (re-runs on file changes)
+```
+
+Tests use [Vitest](https://vitest.dev/) and cover frontmatter parsing, skill discovery, installation logic, and SKILL.md validation across the repo.
+
 The CLI is written in TypeScript and bundled to ESM with [tsup](https://github.com/egoist/tsup).
 
 ## Repository

package/dist/index.js

@@ -5,6 +5,7 @@ import { Command } from "commander";
 
 // src/commands/list.ts
 import chalk from "chalk";
+import fs2 from "fs-extra";
 
 // src/lib/discovery.ts
 import path from "path";
@@ -34,7 +35,8 @@ var PACKAGE_ROOT = path.resolve(__dirname, "..");
 async function discoverSkills() {
   const libraryPattern = "skills/library/*/SKILL.md";
   const teamPattern = "teams/*/skills/*/SKILL.md";
-  const matches = await fg([libraryPattern, teamPattern], {
+  const toolsetPattern = "toolsets/*/skills/*/SKILL.md";
+  const matches = await fg([libraryPattern, teamPattern, toolsetPattern], {
     cwd: PACKAGE_ROOT,
     absolute: true
   });
@@ -46,8 +48,13 @@ async function discoverSkills() {
     const relativePath = path.relative(PACKAGE_ROOT, match);
     let sourceType;
     let teamName;
+    let toolsetName;
     if (relativePath.startsWith("skills/library/")) {
       sourceType = "library";
+    } else if (relativePath.startsWith("toolsets/")) {
+      sourceType = "toolset";
+      const parts = relativePath.split(path.sep);
+      toolsetName = parts[1];
     } else {
       sourceType = "team";
       const parts = relativePath.split(path.sep);
@@ -59,6 +66,7 @@ async function discoverSkills() {
       sourcePath: skillFolder,
       sourceType,
       teamName,
+      toolsetName,
       frontmatter: data
     });
   }
@@ -79,9 +87,37 @@ async function discoverTeams() {
     skills: skills2
   }));
 }
+async function discoverToolsets() {
+  const skills = await discoverSkills();
+  const toolsetMap = /* @__PURE__ */ new Map();
+  for (const skill of skills) {
+    if (skill.sourceType === "toolset" && skill.toolsetName) {
+      const existing = toolsetMap.get(skill.toolsetName) || [];
+      existing.push(skill);
+      toolsetMap.set(skill.toolsetName, existing);
+    }
+  }
+  const toolsets = [];
+  for (const [name, toolsetSkills] of toolsetMap) {
+    const resourcesPath = path.join(PACKAGE_ROOT, "toolsets", name, "resources");
+    let hasResources = false;
+    if (await fs.pathExists(resourcesPath)) {
+      const entries = await fs.readdir(resourcesPath);
+      hasResources = entries.some((e) => e !== "README.md");
+    }
+    toolsets.push({ name, skills: toolsetSkills, resourcesPath, hasResources });
+  }
+  return toolsets;
+}
 async function findSkill(name) {
   const skills = await discoverSkills();
-  return skills.find((s) => s.name === name && s.sourceType === "library") || skills.find((s) => s.name === name);
+  return skills.find((s) => s.name === name && s.sourceType === "library") || skills.find((s) => s.name === name && s.sourceType === "team") || skills.find((s) => s.name === name);
+}
+async function findToolset(name) {
+  const toolsets = await discoverToolsets();
+  return toolsets.find(
+    (t) => t.name === name || t.name.toLowerCase() === name.toLowerCase()
+  );
 }
 
 // src/commands/list.ts
@@ -100,6 +136,7 @@ async function listSkills() {
   }
   const librarySkills = skills.filter((s) => s.sourceType === "library");
   const teamSkills = skills.filter((s) => s.sourceType === "team");
+  const toolsetSkills = skills.filter((s) => s.sourceType === "toolset");
   if (librarySkills.length > 0) {
     console.log(chalk.bold("\nLibrary"));
     for (const s of librarySkills) {
@@ -120,6 +157,20 @@ ${formatTeamName(team)}`));
       console.log(`  ${chalk.cyan(s.name.padEnd(24))} ${truncate(s.description, 60)}`);
     }
   }
+  const toolsetMap = /* @__PURE__ */ new Map();
+  for (const s of toolsetSkills) {
+    const tsName = s.toolsetName || "unknown";
+    const existing = toolsetMap.get(tsName) || [];
+    existing.push(s);
+    toolsetMap.set(tsName, existing);
+  }
+  for (const [tsName, skillList] of toolsetMap) {
+    console.log(chalk.bold(`
+${tsName} ${chalk.dim("(toolset)")}`));
+    for (const s of skillList) {
+      console.log(`  ${chalk.cyan(s.name.padEnd(24))} ${truncate(s.description, 60)}`);
+    }
+  }
   console.log();
 }
 async function listTeams() {
@@ -136,6 +187,24 @@ async function listTeams() {
   }
   console.log();
 }
+async function listToolsets() {
+  const toolsets = await discoverToolsets();
+  if (toolsets.length === 0) {
+    console.log(chalk.yellow("No toolsets found."));
+    return;
+  }
+  console.log(chalk.bold("\nToolsets"));
+  for (const t of toolsets) {
+    const parts = [`${t.skills.length} skill${t.skills.length !== 1 ? "s" : ""}`];
+    if (t.hasResources) {
+      const entries = await fs2.readdir(t.resourcesPath);
+      const count = entries.filter((e) => e !== "README.md").length;
+      parts.push(`${count} resource${count !== 1 ? "s" : ""}`);
+    }
+    console.log(`  ${chalk.cyan(t.name.padEnd(24))} ${parts.join(", ")}`);
+  }
+  console.log();
+}
 async function listAll() {
   await listSkills();
   const teams = await discoverTeams();
@@ -148,11 +217,26 @@ async function listAll() {
     }
     console.log();
   }
+  const toolsets = await discoverToolsets();
+  if (toolsets.length > 0) {
+    console.log(chalk.bold("Toolsets"));
+    for (const t of toolsets) {
+      const parts = [`${t.skills.length} skill${t.skills.length !== 1 ? "s" : ""}`];
+      if (t.hasResources) {
+        const entries = await fs2.readdir(t.resourcesPath);
+        const count = entries.filter((e) => e !== "README.md").length;
+        parts.push(`${count} resource${count !== 1 ? "s" : ""}`);
+      }
+      console.log(`  ${chalk.cyan(t.name.padEnd(24))} ${parts.join(", ")}`);
+    }
+    console.log();
+  }
 }
 function registerListCommand(program2) {
   const list = program2.command("list").description("List available skills and teams");
   list.command("skills").description("List all available skills").action(listSkills);
   list.command("teams").description("List teams and their skill counts").action(listTeams);
+  list.command("toolsets").description("List toolsets with skill and resource counts").action(listToolsets);
   list.action(listAll);
 }
 
@@ -162,7 +246,7 @@ import chalk3 from "chalk";
 
 // src/lib/clients.ts
 import path2 from "path";
-import fs2 from "fs-extra";
+import fs3 from "fs-extra";
 var ALL_CLIENTS = [
   { name: "Copilot", skillsDir: ".github/skills", detectDir: ".github" },
   { name: "Claude Code", skillsDir: ".claude/skills", detectDir: ".claude" },
@@ -172,7 +256,7 @@ async function detectClients(targetDir) {
   const detected = [];
   for (const client of ALL_CLIENTS) {
     const dirPath = path2.join(targetDir, client.detectDir);
-    if (await fs2.pathExists(dirPath)) {
+    if (await fs3.pathExists(dirPath)) {
       detected.push(client);
     }
   }
@@ -181,20 +265,20 @@ async function detectClients(targetDir) {
 
 // src/lib/installer.ts
 import path3 from "path";
-import fs3 from "fs-extra";
+import fs4 from "fs-extra";
 async function handleFile(srcPath, destPath, options, result, onConflict, contentOverride) {
   const relativeDest = path3.relative(options.targetDir, destPath);
-  if (await fs3.pathExists(destPath)) {
-    const existingContent = await fs3.readFile(destPath, "utf-8");
-    const newContent = contentOverride ?? await fs3.readFile(srcPath, "utf-8");
+  if (await fs4.pathExists(destPath)) {
+    const existingContent = await fs4.readFile(destPath, "utf-8");
+    const newContent = contentOverride ?? await fs4.readFile(srcPath, "utf-8");
     if (existingContent === newContent) {
       result.skipped.push(relativeDest);
       return;
     }
     if (options.force) {
       if (!options.dryRun) {
-        await fs3.ensureDir(path3.dirname(destPath));
-        await fs3.writeFile(destPath, newContent);
+        await fs4.ensureDir(path3.dirname(destPath));
+        await fs4.writeFile(destPath, newContent);
       }
       result.overwritten.push(relativeDest);
     } else if (options.skipExisting) {
@@ -203,8 +287,8 @@ async function handleFile(srcPath, destPath, options, result, onConflict, conten
       const choice = await onConflict(relativeDest);
       if (choice === "overwrite") {
         if (!options.dryRun) {
-          await fs3.ensureDir(path3.dirname(destPath));
-          await fs3.writeFile(destPath, newContent);
+          await fs4.ensureDir(path3.dirname(destPath));
+          await fs4.writeFile(destPath, newContent);
         }
         result.overwritten.push(relativeDest);
       } else {
@@ -215,11 +299,11 @@ async function handleFile(srcPath, destPath, options, result, onConflict, conten
     }
   } else {
     if (!options.dryRun) {
-      await fs3.ensureDir(path3.dirname(destPath));
+      await fs4.ensureDir(path3.dirname(destPath));
       if (contentOverride) {
-        await fs3.writeFile(destPath, contentOverride);
+        await fs4.writeFile(destPath, contentOverride);
       } else {
-        await fs3.copy(srcPath, destPath);
+        await fs4.copy(srcPath, destPath);
       }
     }
     result.created.push(relativeDest);
@@ -233,10 +317,10 @@ async function installSkill(skill, options, onConflict) {
     overwritten: []
   };
   const destFolder = path3.join(options.targetDir, "docs", "ai", "skills", skill.name);
-  const sourceFiles = await fs3.readdir(skill.sourcePath);
+  const sourceFiles = await fs4.readdir(skill.sourcePath);
   for (const file of sourceFiles) {
     const srcFile = path3.join(skill.sourcePath, file);
-    const stat = await fs3.stat(srcFile);
+    const stat = await fs4.stat(srcFile);
     if (stat.isFile()) {
       const destFile = path3.join(destFolder, file);
       await handleFile(srcFile, destFile, options, result, onConflict);
@@ -261,6 +345,30 @@ async function installSkills(skills, options, onConflict) {
   }
   return results;
 }
+async function installResources(toolset, options, onConflict) {
+  const result = {
+    toolset: toolset.name,
+    created: [],
+    skipped: [],
+    overwritten: []
+  };
+  if (!toolset.hasResources) return result;
+  const entries = await fs4.readdir(toolset.resourcesPath);
+  const resourceFiles = entries.filter((e) => e !== "README.md");
+  const destDir = path3.join(options.targetDir, "docs", "ai", "resources");
+  const fileResult = { skill: toolset.name, created: [], skipped: [], overwritten: [] };
+  for (const file of resourceFiles) {
+    const srcFile = path3.join(toolset.resourcesPath, file);
+    const stat = await fs4.stat(srcFile);
+    if (!stat.isFile()) continue;
+    const destFile = path3.join(destDir, file);
+    await handleFile(srcFile, destFile, options, fileResult, onConflict);
+  }
+  result.created = fileResult.created;
+  result.skipped = fileResult.skipped;
+  result.overwritten = fileResult.overwritten;
+  return result;
+}
 
 // src/lib/prompts.ts
 import { select, checkbox, confirm } from "@inquirer/prompts";
@@ -268,6 +376,7 @@ import chalk2 from "chalk";
 async function promptSelectSkills(skills) {
   const librarySkills = skills.filter((s) => s.sourceType === "library");
   const teamSkills = skills.filter((s) => s.sourceType === "team");
+  const toolsetSkills = skills.filter((s) => s.sourceType === "toolset");
   const choices = [];
   if (librarySkills.length > 0) {
     choices.push(
@@ -292,6 +401,21 @@ async function promptSelectSkills(skills) {
       }))
     );
   }
+  const toolsetMap = /* @__PURE__ */ new Map();
+  for (const s of toolsetSkills) {
+    const tsName = s.toolsetName || "unknown";
+    const existing = toolsetMap.get(tsName) || [];
+    existing.push(s);
+    toolsetMap.set(tsName, existing);
+  }
+  for (const [tsName, tsList] of toolsetMap) {
+    choices.push(
+      ...tsList.map((s) => ({
+        name: `${chalk2.dim(`[${tsName}]`)} ${s.name} \u2014 ${truncate2(s.description, 60)}`,
+        value: s
+      }))
+    );
+  }
   return checkbox({
     message: "Select skills to install:",
     choices,
@@ -307,6 +431,15 @@ async function promptSelectTeam(teams) {
     }))
   });
 }
+async function promptSelectToolset(toolsets) {
+  return select({
+    message: "Select a toolset:",
+    choices: toolsets.map((t) => ({
+      name: `${t.name} (${t.skills.length} skill${t.skills.length !== 1 ? "s" : ""}${t.hasResources ? " + resources" : ""})`,
+      value: t
+    }))
+  });
+}
 async function promptSelectClients(allClients, detectedClients) {
   const detectedNames = new Set(detectedClients.map((c) => c.name));
   return checkbox({
@@ -352,7 +485,7 @@ function formatTeamName2(name) {
 }
 
 // src/commands/install.ts
-function printResults(results, options) {
+function printResults(results, options, resourceResult) {
   const prefix = options.dryRun ? chalk3.yellow("[DRY RUN] ") : "";
   const createdWord = options.dryRun ? "would create" : "created";
   const skippedWord = "up to date";
@@ -360,6 +493,16 @@ function printResults(results, options) {
   console.log(`
 ${prefix}${chalk3.bold("Install complete")}
 `);
+  if (resourceResult) {
+    const rParts = [];
+    if (resourceResult.created.length > 0) rParts.push(chalk3.green(`${resourceResult.created.length} ${createdWord}`));
+    if (resourceResult.skipped.length > 0) rParts.push(chalk3.dim(`${resourceResult.skipped.length} ${skippedWord}`));
+    if (resourceResult.overwritten.length > 0) rParts.push(chalk3.yellow(`${resourceResult.overwritten.length} ${overwrittenWord}`));
+    if (rParts.length > 0) {
+      console.log(`  ${chalk3.bold("Resources")}            ${rParts.join(", ")}`);
+      console.log();
+    }
+  }
   console.log("  Skill                   Status");
   console.log("  " + "\u2500".repeat(50));
   for (const r of results) {
@@ -404,7 +547,14 @@ async function installSkillCmd(name, _opts, cmd) {
     dryRun
   };
   const result = await installSkill(skill, options, force || skipExisting ? void 0 : promptConflict);
-  printResults([result], options);
+  let resourceResult;
+  if (skill.sourceType === "toolset" && skill.toolsetName) {
+    const toolset = await findToolset(skill.toolsetName);
+    if (toolset && toolset.hasResources) {
+      resourceResult = await installResources(toolset, options, force || skipExisting ? void 0 : promptConflict);
+    }
+  }
+  printResults([result], options, resourceResult);
 }
 async function installTeamCmd(name, _opts, cmd) {
   const parentOpts = cmd.parent.opts();
@@ -451,16 +601,56 @@ async function installTeamCmd(name, _opts, cmd) {
   );
   printResults(results, options);
 }
+async function installToolsetCmd(name, _opts, cmd) {
+  const parentOpts = cmd.parent.opts();
+  const force = Boolean(parentOpts.force);
+  const skipExisting = Boolean(parentOpts.skipExisting);
+  const dryRun = Boolean(parentOpts.dryRun);
+  const targetDir = path4.resolve(
+    parentOpts.target || process.cwd()
+  );
+  const toolset = await findToolset(name);
+  if (!toolset) {
+    const allToolsets = await discoverToolsets();
+    console.log(chalk3.red(`Toolset "${name}" not found.`));
+    if (allToolsets.length > 0) {
+      console.log(`Available toolsets: ${allToolsets.map((t) => t.name).join(", ")}`);
+    }
+    process.exit(1);
+  }
+  const detected = await detectClients(targetDir);
+  let clients;
+  if (force) {
+    clients = detected.length > 0 ? detected : ALL_CLIENTS;
+  } else {
+    clients = await promptSelectClients(ALL_CLIENTS, detected);
+  }
+  const options = {
+    targetDir,
+    clients,
+    force,
+    skipExisting,
+    dryRun
+  };
+  const conflictHandler = force || skipExisting ? void 0 : promptConflict;
+  let resourceResult;
+  if (toolset.hasResources) {
+    resourceResult = await installResources(toolset, options, conflictHandler);
+  }
+  const results = await installSkills(toolset.skills, options, conflictHandler);
+  printResults(results, options, resourceResult);
+}
 function registerInstallCommand(program2) {
   const install = program2.command("install").description("Install skills").option("--force", "Overwrite existing files without prompting").option("--skip-existing", "Skip files that already exist without prompting").option("--dry-run", "Show what would be installed without writing files").option("--target <dir>", "Install to a different directory (default: CWD)");
   install.command("skill <name>").description("Install a specific skill").action(installSkillCmd);
   install.command("team <name>").description("Install all skills for a team").action(installTeamCmd);
+  install.command("toolset <name>").description("Install all skills and resources for a toolset").action(installToolsetCmd);
 }
 
 // src/commands/interactive.ts
 import { select as select2 } from "@inquirer/prompts";
 import chalk4 from "chalk";
-function printResults2(results, options) {
+function printResults2(results, options, resourceResult) {
   const prefix = options.dryRun ? chalk4.yellow("[DRY RUN] ") : "";
   const createdWord = options.dryRun ? "would create" : "created";
   const skippedWord = "up to date";
@@ -468,6 +658,16 @@ function printResults2(results, options) {
   console.log(`
 ${prefix}${chalk4.bold("Install complete")}
 `);
+  if (resourceResult) {
+    const rParts = [];
+    if (resourceResult.created.length > 0) rParts.push(chalk4.green(`${resourceResult.created.length} ${createdWord}`));
+    if (resourceResult.skipped.length > 0) rParts.push(chalk4.dim(`${resourceResult.skipped.length} ${skippedWord}`));
+    if (resourceResult.overwritten.length > 0) rParts.push(chalk4.yellow(`${resourceResult.overwritten.length} ${overwrittenWord}`));
+    if (rParts.length > 0) {
+      console.log(`  ${chalk4.bold("Resources")}            ${rParts.join(", ")}`);
+      console.log();
+    }
+  }
   console.log("  Skill                   Status");
   console.log("  " + "\u2500".repeat(50));
   for (const r of results) {
@@ -521,6 +721,15 @@ ${formatTeamName3(team)}`));
       );
     }
   }
+  const toolsets = await discoverToolsets();
+  if (toolsets.length > 0) {
+    console.log(chalk4.bold("\nToolsets"));
+    for (const t of toolsets) {
+      console.log(
+        `  ${chalk4.cyan(t.name.padEnd(24))} ${t.skills.length} skill${t.skills.length !== 1 ? "s" : ""}`
+      );
+    }
+  }
   console.log();
 }
 async function runInteractive() {
@@ -530,6 +739,7 @@ async function runInteractive() {
     choices: [
       { name: "Install skill(s)", value: "install-skills" },
       { name: "Install team skills", value: "install-team" },
+      { name: "Install toolset", value: "install-toolset" },
       { name: "List available skills & teams", value: "list" }
     ]
   });
@@ -591,6 +801,33 @@ async function runInteractive() {
     };
     const results = await installSkills(skillsToInstall, options, promptConflict);
     printResults2(results, options);
+  } else if (action === "install-toolset") {
+    const toolsets = await discoverToolsets();
+    if (toolsets.length === 0) {
+      console.log(chalk4.yellow("No toolsets found."));
+      return;
+    }
+    const toolset = await promptSelectToolset(toolsets);
+    const detected = await detectClients(targetDir);
+    const clients = await promptSelectClients(ALL_CLIENTS, detected);
+    const confirmed = await promptConfirmInstall(toolset.skills, clients, targetDir);
+    if (!confirmed) {
+      console.log(chalk4.dim("Cancelled."));
+      return;
+    }
+    const options = {
+      targetDir,
+      clients,
+      force: false,
+      skipExisting: false,
+      dryRun: false
+    };
+    let resourceResult;
+    if (toolset.hasResources) {
+      resourceResult = await installResources(toolset, options, promptConflict);
+    }
+    const results = await installSkills(toolset.skills, options, promptConflict);
+    printResults2(results, options, resourceResult);
   }
 }
 
@@ -604,9 +841,11 @@ program.addHelpText(
   `
 Examples:
   $ npx @groupby/ai-dev                              Interactive mode
-  $ npx @groupby/ai-dev list                          List skills and teams
+  $ npx @groupby/ai-dev list                          List skills, teams, and toolsets
+  $ npx @groupby/ai-dev list toolsets                  List available toolsets
   $ npx @groupby/ai-dev install skill frontend-design Install a single skill
   $ npx @groupby/ai-dev install team brain-studio     Install all team skills
+  $ npx @groupby/ai-dev install toolset rzlv-flow     Install all skills + resources for a toolset
   $ npx @groupby/ai-dev install team brain-studio --dry-run`
 );
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groupby/ai-dev",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Interactive installer for Rezolve Ai development skills",
   "type": "module",
   "bin": {
@@ -9,12 +9,16 @@
   "files": [
     "dist/",
     "skills/",
-    "teams/"
+    "teams/",
+    "toolsets/"
   ],
   "scripts": {
-    "prebuild": "cp -r ../skills ./skills && cp -r ../teams ./teams",
+    "prebuild": "cp -r ../skills ./skills && cp -r ../teams ./teams && cp -r ../toolsets ./toolsets",
     "build": "tsup",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
   },
   "repository": {
     "type": "git",
@@ -28,17 +32,18 @@
     "access": "restricted"
   },
   "dependencies": {
-    "commander": "^13.0.0",
     "@inquirer/prompts": "^7.0.0",
     "chalk": "^5.3.0",
-    "gray-matter": "^4.0.3",
+    "commander": "^13.0.0",
     "fast-glob": "^3.3.0",
-    "fs-extra": "^11.2.0"
+    "fs-extra": "^11.2.0",
+    "gray-matter": "^4.0.3"
   },
   "devDependencies": {
-    "typescript": "^5.5.0",
-    "@types/node": "^20.0.0",
     "@types/fs-extra": "^11.0.0",
-    "tsup": "^8.0.0"
+    "@types/node": "^20.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.5.0",
+    "vitest": "^4.1.3"
   }
 }

package/toolsets/rzlv-flow/README.md

@@ -0,0 +1,57 @@
+# rzlv-flow: Atlassian Intelligence Skills
+
+A toolset of modular, composable skills for Jira and Confluence developer workflows. Covers daily triage, ticket focus, wrap/sync, sprint status, context loading, and more — all without requiring the full BMAD Method or the rzlv-flow monolith.
+
+Each skill is standalone and can be installed individually or as a complete suite.
+
+## Skills
+
+| Skill | Description | Status |
+|-------|-------------|--------|
+| `jira-daily-triage` | Start-of-day ticket triage with sprint detection | Planned |
+| `jira-ticket-focus` | Deep-load a ticket with full context | Planned |
+| `jira-wrap-sync` | Wrap up work, draft comment, multi-action sync | Planned |
+| `jira-ticket-trace` | Trace code back to Jira requirements | Planned |
+| `jira-comment` | Add a comment to a Jira ticket with FCMP safety | Planned |
+| `jira-status` | Change ticket status with transition validation | Planned |
+| `jira-sprint-status` | Sprint status report with completion metrics | Planned |
+| `jira-sync` | Force-sync local Jira context with remote state | Planned |
+| `atlassian-orchestrator` | Pull surrounding ticket context and create structures | Complete |
+| `context-analyst` | Transform meeting transcripts into structured docs | Complete |
+
+## Prerequisites
+
+### Required: Atlassian MCP (`atlassian-rovo`)
+
+All Jira and Confluence skills require the Atlassian MCP server for API access to your Atlassian instance.
+
+### Optional: GitHub MCP
+
+Only needed for PR creation features in `jira-wrap-sync`. Not required for any other skills.
+
+See [docs/mcp-setup.md](docs/mcp-setup.md) for detailed setup instructions.
+
+## Installation
+
+```bash
+npx @groupby/ai-dev install toolset rzlv-flow       # All skills + resources
+npx @groupby/ai-dev install skill jira-daily-triage   # Individual skill
+```
+
+> **Note:** CLI toolset support is coming soon. For now, skills can be copied manually from this repository into your project's `docs/ai/skills/` directory, and resources into `docs/ai/resources/`.
+
+## BMAD Compatibility
+
+These skills are compatible with BMAD's Jira file structure (`docs/jira/{instance}/{project}/...`) but do **not** require BMAD. They were originally developed as part of the BMAD "Atlassian Intelligence Suite" and have been extracted as standalone skills. If BMAD is installed in your project, these skills coexist without conflict.
+
+## Shared Resources
+
+Skills reference shared resource files installed to `docs/ai/resources/` in your project:
+
+| Resource | Description |
+|----------|-------------|
+| `fcmp-protocol.md` | Fetch-Compare-Merge-Push sync pattern for safe Atlassian read/write |
+| `jira-file-structure.md` | Standard directory layout for local Jira mirrors |
+| `confluence-file-structure.md` | Leaf Bundle pattern for Confluence page mirrors |
+| `sync-state-format.md` | YAML frontmatter schema for ticket and page files |
+| `confluence-page-templates/` | Starter scaffolds for Confluence pages (initiative overview, strategic context, technical architecture, decisions) |