@ionivetech/mugiwara 0.1.0

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@ionivetech/mugiwara",
+  "version": "0.1.0",
+  "description": "The Straw Hat crew of AI agents and skills: brainstorm, plan, execute, checkpoint, quality, gates, review, security, self-healing. Installs into Claude Code, opencode, Copilot, Gemini, Codex, Windsurf, Cline, Kilo, Antigravity.",
+  "type": "module",
+  "license": "MIT",
+  "bin": {
+    "mugiwara": "dist/mugiwara.js"
+  },
+  "files": ["dist", "src", "content", "scripts/install.sh", "scripts/install.ps1", "README.md", "LICENSE"],
+  "engines": {
+    "node": ">=20.11"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "build": "bun build src/cli.ts --outfile dist/mugiwara.js --target node --format esm",
+    "validate": "bun scripts/validate-content.ts",
+    "evals": "bun scripts/run-evals.ts",
+    "prepack": "bun run build"
+  },
+  "keywords": ["ai", "agents", "skills", "claude-code", "opencode", "copilot", "gemini", "codex", "windsurf", "cline", "multi-agent", "workflow"],
+  "devDependencies": {
+    "@types/node": "^26.2.0",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10"
+  }
+}

package/scripts/install.ps1

@@ -0,0 +1,14 @@
+#Requires -Version 5.1
+$ErrorActionPreference = 'Stop'
+
+if (-not (Get-Command node -ErrorAction SilentlyContinue)) {
+  Write-Error 'mugiwara requires Node.js >= 20. Install it from https://nodejs.org first.'
+}
+
+$major = [int](node -p 'process.versions.node.split(".")[0]')
+if ($major -lt 20) {
+  Write-Error "mugiwara requires Node.js >= 20 (found $(node --version))."
+}
+
+npx -y @ionivetech/mugiwara@latest @args
+exit $LASTEXITCODE

package/scripts/install.sh

@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+PKG="@ionivetech/mugiwara"
+
+if ! command -v node >/dev/null 2>&1; then
+  echo "mugiwara requires Node.js >= 20. Install it first: https://nodejs.org" >&2
+  exit 1
+fi
+
+MAJOR="$(node -p 'process.versions.node.split(".")[0]')"
+if [ "$MAJOR" -lt 20 ]; then
+  echo "mugiwara requires Node.js >= 20 (found $(node --version))." >&2
+  exit 1
+fi
+
+exec npx -y "${PKG}@latest" "$@"

package/src/args.ts

@@ -0,0 +1,31 @@
+// src/args.ts
+export type FlagValue = string | boolean | undefined;
+export type Args = {
+  command: string;
+  _: string[];
+  flags: Record<string, FlagValue>;
+};
+
+const VALUE_FLAGS: Record<string, string> = { '--project': 'project', '--target': 'target', '--type': 'type' };
+const BOOL_FLAGS: Record<string, string> = {
+  '--global': 'global', '--yes': 'yes', '-y': 'yes', '--force': 'force',
+  '--dry-run': 'dryRun', '--help': 'help', '-h': 'help', '--version': 'version', '-v': 'version',
+};
+
+export function parseArgs(argv: string[]): Args {
+  const out: Args = { _: [], flags: {}, command: 'install' };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a in BOOL_FLAGS) { out.flags[BOOL_FLAGS[a]] = true; continue; }
+    if (a in VALUE_FLAGS) {
+      const v = argv[++i];
+      if (v === undefined || v.startsWith('-')) throw new Error(`Flag ${a} missing value`);
+      out.flags[VALUE_FLAGS[a]] = v;
+      continue;
+    }
+    if (a.startsWith('-')) throw new Error(`Unknown flag: ${a}`);
+    out._.push(a);
+  }
+  out.command = out._[0] ?? 'install';
+  return out;
+}

package/src/cli.ts

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+// src/cli.ts
+import { existsSync, readFileSync, readdirSync, realpathSync, rmSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { parseArgs, type FlagValue, type Args } from './args.ts';
+import { createRl, choose, multiChoose, confirm } from './prompt.ts';
+import { targets, TARGET_IDS } from './targets/index.ts';
+import { installTo, removeInstalled, VERSION, CONTENT_DIR } from './installer.ts';
+import { manifestPath, readManifest, writeManifest, type Scope } from './manifest.ts';
+import { parseFrontmatter } from './frontmatter.ts';
+
+const TYPES = ['frontend', 'backend', 'fullstack', 'general'];
+
+const str = (v: FlagValue): string | undefined => (typeof v === 'string' ? v : undefined);
+const flag = (v: FlagValue): boolean => v === true;
+
+export async function run(argv: string[]): Promise<void> {
+  const { command, flags } = parseArgs(argv);
+  if (flag(flags.help) || command === 'help') return help();
+  if (flag(flags.version)) { console.log(`mugiwara ${VERSION}`); return; }
+  switch (command) {
+    case 'install': return install(flags);
+    case 'update': return install({ ...flags, force: true });
+    case 'uninstall': return uninstall(flags);
+    case 'list': return list(flags);
+    case 'skills': return skills();
+    default: throw new Error(`Unknown command: ${command}`);
+  }
+}
+
+async function resolveOptions(flags: Args['flags']): Promise<{ scope: Scope; projectDir: string; targetIds: string[]; type: string }> {
+  const interactive = !flag(flags.yes);
+  const rl = interactive ? createRl() : null;
+  try {
+    let scope: Scope | null = flag(flags.global) ? 'global' : str(flags.project) ? 'project' : null;
+    if (!scope) {
+      if (!interactive) throw new Error('Specify --global or --project <dir> with --yes');
+      scope = (await choose(rl!, 'Install scope?', ['global (user-wide)', 'project (this repo)'])) === 0 ? 'global' : 'project';
+    }
+    const projectDir = resolve(str(flags.project) ?? process.cwd());
+    if (scope === 'project' && !existsSync(projectDir)) throw new Error(`Project dir not found: ${projectDir}`);
+
+    let targetIds = str(flags.target)?.split(',').map(s => s.trim()) ?? null;
+    if (targetIds && targetIds.includes('all')) targetIds = [...TARGET_IDS];
+    if (!targetIds) {
+      if (!interactive) throw new Error('Specify --target <ids|all> with --yes');
+      const idx = await multiChoose(rl!, 'Target AI agents?', ['all targets', ...TARGET_IDS]);
+      targetIds = idx.includes(0) ? [...TARGET_IDS] : idx.map(i => TARGET_IDS[i - 1]);
+    }
+    for (const id of targetIds) {
+      if (!targets[id]) throw new Error(`Unknown target: ${id} (valid: ${TARGET_IDS.join(', ')}, all)`);
+    }
+
+    let type = str(flags.type) ?? null;
+    if (!type) {
+      if (!interactive) throw new Error('Specify --type with --yes');
+      type = TYPES[await choose(rl!, 'Project type?', TYPES)];
+    }
+    if (!TYPES.includes(type)) throw new Error(`Unknown type: ${type} (valid: ${TYPES.join(', ')})`);
+    return { scope, projectDir, targetIds, type };
+  } finally {
+    if (rl) rl.close();
+  }
+}
+
+async function install(flags: Args['flags']): Promise<void> {
+  const { scope, projectDir, targetIds, type } = await resolveOptions(flags);
+  const home = homedir();
+  const allFiles: string[] = [];
+  const allNotes: string[] = [];
+  const installed: string[] = [];
+  for (const id of targetIds) {
+    const t = targets[id];
+    if (scope === 'global' && !t.native) {
+      console.log(`! ${t.label}: project scope only — skipped for global install`);
+      continue;
+    }
+    installed.push(id);
+    console.log(`\n-> ${t.label} (${scope})`);
+    const r = installTo(t, { scope, projectDir, type, home, dryRun: flag(flags.dryRun), force: flag(flags.force) });
+    console.log(`   written ${r.written.length}, skipped ${r.skipped.length}, backed up ${r.backedUp.length}`);
+    for (const n of r.notes) console.log(`   note: ${n}`);
+    allFiles.push(...r.written);
+    allNotes.push(...r.notes);
+  }
+  if (flag(flags.dryRun)) { console.log('\nDry run — nothing written.'); return; }
+  const file = manifestPath({ scope, projectDir, home });
+  const prev = readManifest(file);
+  writeManifest(file, {
+    version: VERSION,
+    scope,
+    type,
+    installedAt: new Date().toISOString(),
+    targets: [...new Set([...(prev?.targets ?? []), ...installed])],
+    files: [...new Set([...(prev?.files ?? []), ...allFiles])],
+  });
+  console.log(`\nOK mugiwara ${VERSION} installed (manifest: ${file})`);
+  if (allNotes.length) console.log(`${allNotes.length} note(s) above may need attention.`);
+}
+
+async function uninstall(flags: Args['flags']): Promise<void> {
+  const scope: Scope = flag(flags.global) ? 'global' : 'project';
+  const projectDir = resolve(str(flags.project) ?? process.cwd());
+  const home = homedir();
+  const file = manifestPath({ scope, projectDir, home });
+  const manifest = readManifest(file);
+  if (!manifest) { console.log('Nothing installed (no manifest found).'); return; }
+  console.log(`Will remove ${manifest.files.length} files (targets: ${manifest.targets.join(', ')}).`);
+  if (!flag(flags.yes)) {
+    const rl = createRl();
+    const ok = await confirm(rl, 'Proceed?');
+    rl.close();
+    if (!ok) { console.log('Aborted.'); return; }
+  }
+  const removed = removeInstalled(manifest, { dryRun: flag(flags.dryRun) });
+  if (!flag(flags.dryRun)) rmSync(file);
+  console.log(`OK removed ${removed.length} files`);
+}
+
+function list(flags: Args['flags']): void {
+  const home = homedir();
+  const projectDir = resolve(str(flags.project) ?? process.cwd());
+  let found = false;
+  for (const [label, file] of [
+    ['project', manifestPath({ scope: 'project', projectDir, home })],
+    ['global', manifestPath({ scope: 'global', projectDir, home })],
+  ]) {
+    const m = readManifest(file);
+    if (!m) continue;
+    found = true;
+    console.log(`${label}: v${m.version} targets=${m.targets.join(',')} files=${m.files.length} installed=${m.installedAt}`);
+  }
+  if (!found) console.log('No mugiwara installation found.');
+}
+
+function skills(): void {
+  const dir = join(CONTENT_DIR, 'skills');
+  const names = readdirSync(dir, { withFileTypes: true }).filter(e => e.isDirectory()).map(e => e.name).sort();
+  const rows = names.map(name => {
+    const { data } = parseFrontmatter(readFileSync(join(dir, name, 'SKILL.md'), 'utf8'));
+    return [name, data.description ?? ''] as const;
+  });
+  const w = Math.max(...rows.map(r => r[0].length)) + 2;
+  console.log(`mugiwara ${VERSION} — ${rows.length} skills (agentskills.io format):\n`);
+  for (const [name, description] of rows) console.log(`  ${name.padEnd(w)}${description}`);
+  console.log(`\nInstall skills into any agent via skills.sh:\n  npx skills add ionivetech/mugiwara`);
+}
+
+function help(): void {
+  console.log(`mugiwara ${VERSION} — the Straw Hat crew for AI agents
+
+Usage:
+  mugiwara [install]     install the crew (default; wizard when flags missing)
+  mugiwara update        replace existing files (backs up differences first)
+  mugiwara uninstall     remove installed files via manifest
+  mugiwara list          show installations
+  mugiwara skills        list installable skills (agentskills.io)
+  mugiwara --help        this help
+  mugiwara --version     print version
+
+Flags:
+  --global               user-wide install
+  --project <dir>        project install (default: cwd)
+  --target <ids|all>     comma-separated: ${TARGET_IDS.join(', ')}
+  --type <t>             frontend | backend | fullstack | general
+  --yes, -y              non-interactive (needs --global/--project, --target, --type)
+  --force                overwrite differing files (with backup)
+  --dry-run              print actions without writing`);
+}
+
+let entry = process.argv[1] !== undefined ? resolve(process.argv[1]) : undefined;
+if (entry !== undefined) {
+  try {
+    entry = realpathSync(entry);
+  } catch {
+    // ponytail: realpath can throw on a missing/odd path — fall back to the raw resolve
+  }
+}
+const isMain = entry !== undefined && import.meta.url === pathToFileURL(entry).href;
+if (isMain) {
+  run(process.argv.slice(2)).catch(err => {
+    console.error(`mugiwara: ${err.message}`);
+    process.exit(1);
+  });
+}

package/src/frontmatter.ts

@@ -0,0 +1,20 @@
+// src/frontmatter.ts
+export type FrontmatterData = Record<string, string>;
+
+export function parseFrontmatter(text: string): { data: FrontmatterData; body: string } {
+  const m = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
+  if (!m) throw new Error('Missing frontmatter fence (---)');
+  const data: FrontmatterData = {};
+  for (const line of m[1].split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    const i = line.indexOf(':');
+    if (i === -1) throw new Error(`Bad frontmatter line: ${line}`);
+    data[line.slice(0, i).trim()] = line.slice(i + 1).trim();
+  }
+  return { data, body: text.slice(m[0].length) };
+}
+
+export function stringifyFrontmatter(data: FrontmatterData, body: string): string {
+  const lines = Object.entries(data).map(([k, v]) => `${k}: ${v}`);
+  return `---\n${lines.join('\n')}\n---\n${body}`;
+}

package/src/installer.ts

@@ -0,0 +1,118 @@
+// src/installer.ts
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, copyFileSync, rmSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+import { parseFrontmatter, type FrontmatterData } from './frontmatter.ts';
+import type { Scope } from './manifest.ts';
+
+export type ContentItem = { name: string; data: FrontmatterData; body: string };
+
+export type InstallOptions = {
+  scope: Scope;
+  projectDir: string;
+  type: string;
+  dryRun?: boolean;
+  force?: boolean;
+  home?: string;
+};
+
+export type InstallResult = {
+  written: string[];
+  skipped: string[];
+  backedUp: string[];
+  notes: string[];
+};
+
+export type TransformOut = { relPath: string; text: string } | null;
+
+export interface Target {
+  id: string;
+  label: string;
+  native: boolean;
+  paths(opts: { scope: Scope; projectDir: string; home: string }): { skillsDir: string; agentsDir: string };
+  transformSkill(data: FrontmatterData, body: string): TransformOut;
+  transformAgent(data: FrontmatterData, body: string): TransformOut;
+  postInstall?(opts: { scope: Scope; projectDir: string; home: string; dryRun: boolean; files: string[] }): { written: string[]; notes: string[] };
+}
+
+export const CONTENT_DIR = join(import.meta.dirname, '..', 'content');
+const pkg = JSON.parse(readFileSync(join(import.meta.dirname, '..', 'package.json'), 'utf8')) as { version: string };
+export const VERSION = pkg.version;
+
+export function collectContent({ includeFrontend }: { includeFrontend: boolean }): { skills: ContentItem[]; agents: ContentItem[] } {
+  const skillNames = readdirSync(join(CONTENT_DIR, 'skills'), { withFileTypes: true })
+    .filter(e => e.isDirectory()).map(e => e.name)
+    .filter(name => includeFrontend || name !== 'mugiwara-frontend');
+  const skills = skillNames.map(name => {
+    const { data, body } = parseFrontmatter(readFileSync(join(CONTENT_DIR, 'skills', name, 'SKILL.md'), 'utf8'));
+    return { name, data, body };
+  });
+  const agents = readdirSync(join(CONTENT_DIR, 'agents'))
+    .filter(f => f.endsWith('.md'))
+    .map(f => {
+      const { data, body } = parseFrontmatter(readFileSync(join(CONTENT_DIR, 'agents', f), 'utf8'));
+      return { name: f.replace(/\.md$/, ''), data, body };
+    });
+  return { skills, agents };
+}
+
+export function installTo(target: Target, opts: InstallOptions): InstallResult {
+  const { scope, projectDir, type, dryRun = false, force = false } = opts;
+  const home = opts.home ?? homedir();
+  const { skills, agents } = collectContent({ includeFrontend: type === 'frontend' || type === 'fullstack' });
+  const dirs = target.paths({ scope, projectDir, home });
+  const backupRoot = join(scope === 'global' ? home : projectDir, '.mugiwara');
+  const result: InstallResult = { written: [], skipped: [], backedUp: [], notes: [] };
+
+  const writeOne = (absPath: string, text: string) => {
+    if (existsSync(absPath)) {
+      if (readFileSync(absPath, 'utf8') === text) { result.skipped.push(absPath); return; }
+      if (!force) {
+        result.skipped.push(absPath);
+        result.notes.push(`conflict (not overwritten; run update to replace with backup): ${absPath}`);
+        return;
+      }
+      const ts = new Date().toISOString().replace(/[:.]/g, '-');
+      const backupFile = join(backupRoot, 'backup', ts, absPath.replace(/[^a-zA-Z0-9]+/g, '_'));
+      if (!dryRun) { mkdirSync(dirname(backupFile), { recursive: true }); copyFileSync(absPath, backupFile); }
+      result.backedUp.push(absPath);
+    }
+    if (!dryRun) { mkdirSync(dirname(absPath), { recursive: true }); writeFileSync(absPath, text); }
+    result.written.push(absPath);
+  };
+
+  for (const s of skills) {
+    const out = target.transformSkill(s.data, s.body);
+    if (out) writeOne(join(dirs.skillsDir, out.relPath), out.text);
+  }
+  for (const a of agents) {
+    const out = target.transformAgent(a.data, a.body);
+    if (out) writeOne(join(dirs.agentsDir, out.relPath), out.text);
+  }
+
+  if (target.postInstall) {
+    const post = target.postInstall({ scope, projectDir, home, dryRun, files: result.written });
+    result.written.push(...post.written);
+    result.notes.push(...post.notes);
+  }
+  return result;
+}
+
+export function removeInstalled(manifest: { files: string[] }, { dryRun = false }: { dryRun?: boolean } = {}): string[] {
+  const removed: string[] = [];
+  for (const f of manifest.files) {
+    if (existsSync(f)) { if (!dryRun) rmSync(f); removed.push(f); }
+  }
+  if (!dryRun) {
+    for (const f of manifest.files) {
+      let d = dirname(f);
+      while (existsSync(d) && readdirSync(d).length === 0) {
+        rmSync(d, { recursive: true });
+        const parent = dirname(d);
+        if (parent === d) break;
+        d = parent;
+      }
+    }
+  }
+  return removed;
+}

package/src/manifest.ts

@@ -0,0 +1,29 @@
+// src/manifest.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
+export type Scope = 'global' | 'project';
+
+export type Manifest = {
+  version: string;
+  scope: Scope;
+  type: string;
+  installedAt: string;
+  targets: string[];
+  files: string[];
+};
+
+export function manifestPath({ scope, projectDir, home }: { scope: Scope; projectDir: string; home: string }): string {
+  return scope === 'global'
+    ? join(home, '.mugiwara', 'manifest.json')
+    : join(projectDir, '.mugiwara', 'manifest.json');
+}
+
+export function readManifest(file: string): Manifest | null {
+  return existsSync(file) ? JSON.parse(readFileSync(file, 'utf8')) as Manifest : null;
+}
+
+export function writeManifest(file: string, data: Manifest): void {
+  mkdirSync(dirname(file), { recursive: true });
+  writeFileSync(file, JSON.stringify(data, null, 2) + '\n');
+}

package/src/prompt.ts

@@ -0,0 +1,37 @@
+// src/prompt.ts
+import readline from 'node:readline/promises';
+
+export type Rl = { question: (prompt: string) => Promise<string> };
+
+export function createRl(): readline.Interface {
+  return readline.createInterface({ input: process.stdin, output: process.stdout });
+}
+
+export async function choose(rl: Rl, question: string, options: string[]): Promise<number> {
+  for (;;) {
+    console.log(`\n${question}`);
+    options.forEach((o, i) => console.log(`  ${i + 1}) ${o}`));
+    const n = Number((await rl.question('choice> ')).trim());
+    if (Number.isInteger(n) && n >= 1 && n <= options.length) return n - 1;
+    console.log(`Enter a number between 1 and ${options.length}.`);
+  }
+}
+
+export async function multiChoose(rl: Rl, question: string, options: string[]): Promise<number[]> {
+  for (;;) {
+    console.log(`\n${question} (comma-separated numbers, or "all")`);
+    options.forEach((o, i) => console.log(`  ${i + 1}) ${o}`));
+    const raw = (await rl.question('choices> ')).trim().toLowerCase();
+    if (raw === 'all') return options.map((_, i) => i);
+    const nums = raw.split(',').map(s => Number(s.trim()));
+    if (nums.length > 0 && nums.every(n => Number.isInteger(n) && n >= 1 && n <= options.length)) {
+      return [...new Set(nums.map(n => n - 1))];
+    }
+    console.log('Invalid selection.');
+  }
+}
+
+export async function confirm(rl: Rl, question: string): Promise<boolean> {
+  const raw = (await rl.question(`${question} [y/N] `)).trim().toLowerCase();
+  return raw === 'y' || raw === 'yes';
+}

package/src/targets/antigravity.ts

@@ -0,0 +1,10 @@
+// src/targets/antigravity.ts
+import { makeGeneric } from './generic.ts';
+
+export const target = makeGeneric({
+  id: 'antigravity',
+  label: 'Antigravity',
+  rulesDir: '.agents/rules',
+  bootstrapFile: null,
+  bootstrapPointer: null,
+});

package/src/targets/claude.ts

@@ -0,0 +1,25 @@
+// src/targets/claude.ts
+import { join } from 'node:path';
+import { stringifyFrontmatter, type FrontmatterData } from '../frontmatter.ts';
+import type { Target } from '../installer.ts';
+
+export const target: Target = {
+  id: 'claude',
+  label: 'Claude Code',
+  native: true,
+  paths({ scope, projectDir, home }) {
+    const root = scope === 'global' ? join(home, '.claude') : join(projectDir, '.claude');
+    return { skillsDir: join(root, 'skills'), agentsDir: join(root, 'agents') };
+  },
+  transformSkill(data: FrontmatterData, body: string) {
+    return {
+      relPath: join(data.name, 'SKILL.md'),
+      text: stringifyFrontmatter({ name: data.name, description: data.description }, body),
+    };
+  },
+  transformAgent(data: FrontmatterData, body: string) {
+    const fm: FrontmatterData = { name: data.name, description: data.description };
+    if (data.tools) fm.tools = data.tools;
+    return { relPath: `${data.name}.md`, text: stringifyFrontmatter(fm, body) };
+  },
+};

package/src/targets/cline.ts

@@ -0,0 +1,10 @@
+// src/targets/cline.ts
+import { makeGeneric } from './generic.ts';
+
+export const target = makeGeneric({
+  id: 'cline',
+  label: 'Cline',
+  rulesDir: '.clinerules',
+  bootstrapFile: null,
+  bootstrapPointer: null,
+});

package/src/targets/codex.ts

@@ -0,0 +1,10 @@
+// src/targets/codex.ts
+import { makeGeneric } from './generic.ts';
+
+export const target = makeGeneric({
+  id: 'codex',
+  label: 'Codex',
+  rulesDir: '.codex/mugiwara',
+  bootstrapFile: 'AGENTS.md',
+  bootstrapPointer: 'Mugiwara crew installed in .codex/mugiwara/ — read .codex/mugiwara/mugiwara-workflow.md to run the pipeline.',
+});

package/src/targets/copilot.ts

@@ -0,0 +1,26 @@
+// src/targets/copilot.ts
+import { join } from 'node:path';
+import { stringifyFrontmatter, type FrontmatterData } from '../frontmatter.ts';
+import type { Target } from '../installer.ts';
+
+export const target: Target = {
+  id: 'copilot',
+  label: 'GitHub Copilot',
+  native: true,
+  paths({ scope, projectDir, home }) {
+    const root = scope === 'global' ? join(home, '.copilot') : join(projectDir, '.github');
+    return { skillsDir: join(root, 'instructions'), agentsDir: join(root, 'agents') };
+  },
+  transformSkill(data: FrontmatterData, body: string) {
+    return {
+      relPath: `${data.name}.instructions.md`,
+      text: stringifyFrontmatter({ description: data.description, applyTo: '**/*' }, body),
+    };
+  },
+  transformAgent(data: FrontmatterData, body: string) {
+    return {
+      relPath: `${data.name}.md`,
+      text: stringifyFrontmatter({ name: data.name, description: data.description }, body),
+    };
+  },
+};

package/src/targets/gemini.ts

@@ -0,0 +1,10 @@
+// src/targets/gemini.ts
+import { makeGeneric } from './generic.ts';
+
+export const target = makeGeneric({
+  id: 'gemini',
+  label: 'Gemini',
+  rulesDir: '.gemini/mugiwara',
+  bootstrapFile: 'GEMINI.md',
+  bootstrapPointer: 'Mugiwara crew installed in .gemini/mugiwara/ — read .gemini/mugiwara/mugiwara-workflow.md to run the pipeline.',
+});

package/src/targets/generic.ts

@@ -0,0 +1,43 @@
+// src/targets/generic.ts
+import { existsSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import type { Target } from '../installer.ts';
+
+export function makeGeneric(opts: {
+  id: string;
+  label: string;
+  rulesDir: string;
+  bootstrapFile: string | null;
+  bootstrapPointer: string | null;
+}): Target {
+  const { id, label, rulesDir, bootstrapFile, bootstrapPointer } = opts;
+  return {
+    id,
+    label,
+    native: false,
+    paths({ scope, projectDir }: { scope: 'global' | 'project'; projectDir: string; home: string }) {
+      if (scope === 'global') throw new Error(`${label} supports project scope only`);
+      const dir = join(projectDir, rulesDir);
+      return { skillsDir: dir, agentsDir: dir };
+    },
+    transformSkill(data, body) {
+      return { relPath: `${data.name}.md`, text: `# ${data.name}\n\n> ${data.description}\n\n${body}` };
+    },
+    transformAgent(data, body) {
+      return { relPath: `agent-${data.name}.md`, text: `# Agent: ${data.name}\n\n> ${data.description}\n\nSkills used: ${data.skills ?? ''}\n\n${body}` };
+    },
+    postInstall({ projectDir, dryRun }) {
+      if (!bootstrapFile) return { written: [], notes: [] };
+      const notes: string[] = [];
+      const written: string[] = [];
+      const file = join(projectDir, bootstrapFile);
+      if (!existsSync(file)) {
+        if (!dryRun) writeFileSync(file, `${bootstrapPointer}\n`);
+        written.push(file);
+      } else {
+        notes.push(`add this line to ${bootstrapFile} so the agent finds the crew: "${bootstrapPointer}"`);
+      }
+      return { written, notes };
+    },
+  };
+}

package/src/targets/index.ts

@@ -0,0 +1,14 @@
+// src/targets/index.ts
+import type { Target } from '../installer.ts';
+import { target as claude } from './claude.ts';
+import { target as opencode } from './opencode.ts';
+import { target as copilot } from './copilot.ts';
+import { target as gemini } from './gemini.ts';
+import { target as codex } from './codex.ts';
+import { target as windsurf } from './windsurf.ts';
+import { target as cline } from './cline.ts';
+import { target as kilo } from './kilo.ts';
+import { target as antigravity } from './antigravity.ts';
+
+export const targets: Record<string, Target> = { claude, opencode, copilot, gemini, codex, windsurf, cline, kilo, antigravity };
+export const TARGET_IDS = Object.keys(targets);

package/src/targets/kilo.ts

@@ -0,0 +1,10 @@
+// src/targets/kilo.ts
+import { makeGeneric } from './generic.ts';
+
+export const target = makeGeneric({
+  id: 'kilo',
+  label: 'Kilo Code',
+  rulesDir: '.kilo/rules',
+  bootstrapFile: 'kilo.jsonc',
+  bootstrapPointer: '{\n  "instructions": [\n    ".kilo/rules/*.md"\n  ]\n}',
+});