@ionivetech/mugiwara 0.5.1 → 0.5.3

package/hooks/mugiwara-mode-tracker.ts

@@ -0,0 +1,80 @@
+#!/usr/bin/env bun
+// hooks/mugiwara-mode-tracker.ts — UserPromptSubmit hook: intercepts
+// /mugiwara <mode> commands in Claude Code chat and writes .mugiwara/config.
+// Same logic as the OpenCode plugin's chat.message hook, standalone for
+// Claude Code's hook process model.
+//
+// Input:  JSON on stdin with { prompt: "..." }
+// Output: JSON on stdout with { prompt: "..." } (pass-through)
+
+const VALID_MODES = new Set(['guided', 'semi', 'auto']);
+
+function parseModeChange(promptRaw: string): string | null {
+  if (typeof promptRaw !== 'string') return null;
+  let prompt = promptRaw.trim();
+  const wrapped = /^(["'`])([\s\S]*)\1$/.exec(prompt);
+  if (wrapped) prompt = wrapped[2].trim();
+  prompt = prompt.toLowerCase();
+  if (!prompt) return null;
+
+  const tplSet = /^(?:set |)mugiwara mode:[ \t]*(\S*)/.exec(prompt);
+  if (tplSet && VALID_MODES.has(tplSet[1])) return tplSet[1];
+
+  const slashMode = /^\/(?:mugiwara[-\s]?)?mode[ \t]+(\S*)/.exec(prompt);
+  if (slashMode && VALID_MODES.has(slashMode[1])) return slashMode[1];
+
+  const slashMain = /^\/mugiwara[ \t]+(\S*)/.exec(prompt);
+  if (slashMain && VALID_MODES.has(slashMain[1])) return slashMain[1];
+
+  const natural = /^mugiwara mode[ \t]+(\S*)/.exec(prompt);
+  if (natural && VALID_MODES.has(natural[1])) return natural[1];
+
+  return null;
+}
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from 'node:fs';
+import { homedir, tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+
+function applyModeChange(mode: string) {
+  if (!VALID_MODES.has(mode)) return;
+  const cwd = process.env.CLAUDE_PROJECT_DIR ?? process.cwd();
+  const dir = join(cwd, '.mugiwara');
+  const file = join(dir, 'config');
+  mkdirSync(dir, { recursive: true });
+  const lines: string[] = [];
+  if (existsSync(file)) {
+    for (const line of readFileSync(file, 'utf8').split(/\r?\n/)) {
+      const t = line.trim();
+      if (t.startsWith('mode=')) continue;
+      lines.push(line);
+    }
+  }
+  lines.push(`mode=${mode}`);
+  const body = lines.filter((_l, i) => !(lines[i] === '' && (i === lines.length - 1 || i === 0))).join('\n') + '\n';
+  const tmp = join(tmpdir(), `mugiwara-config-${process.pid}-${Date.now()}.tmp`);
+  writeFileSync(tmp, body);
+  renameSync(tmp, file);
+}
+
+// main
+async function main() {
+  let input = '';
+  for await (const chunk of process.stdin) input += chunk;
+  if (!input.trim()) { process.stdout.write(JSON.stringify({ prompt: '' })); return; }
+
+  let parsed: { prompt?: string };
+  try { parsed = JSON.parse(input); } catch { parsed = { prompt: input }; }
+  const prompt = parsed.prompt ?? '';
+
+  const change = parseModeChange(prompt);
+  if (change) applyModeChange(change);
+
+  // pass-through — always return the prompt unchanged
+  process.stdout.write(JSON.stringify({ prompt }));
+}
+
+main().catch(() => {
+  // silent — hook must never block the conversation
+  process.stdout.write(JSON.stringify({ prompt: '' }));
+});

package/hooks/session-start.ts

@@ -3,6 +3,6 @@
 console.log(
   JSON.stringify({
     additionalContext:
-      "Mugiwara crew available. The workflow auto-activates for non-trivial requests (no need to call `/using-mugiwara` at session start; it is optional and routes to the right crew member). The crew runs inline in the main thread — Never Task-dispatch a crew member. Subagents only for [PARALLEL] task batches, concurrent review/security, and independent re-run checks. Checkpoint reports at wave/stage boundaries. Mode: guided / semi / auto (see .mugiwara/config). See skills/mugiwara-workflow."
+      "Mugiwara crew available. The workflow auto-activates for non-trivial requests (no need to call `/using-mugiwara` at session start; it is optional and routes to the right crew member). The crew runs inline in the main thread — Never Task-dispatch a crew member. Subagents only for [PARALLEL] task batches, concurrent review/security, and independent re-run checks. Checkpoint reports at wave/stage boundaries. Mode: guided / semi / auto (see .mugiwara/config). Switch with `/mugiwara <mode>`. See skills/mugiwara-workflow."
   })
 );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ionivetech/mugiwara",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "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, Cursor, Kimi, pi, Windsurf, Cline, Kilo, Antigravity.",
   "type": "module",
   "license": "MIT",
@@ -22,7 +22,16 @@
     "evals",
     "scripts",
     ".opencode",
+    ".claude-plugin",
+    ".codex-plugin",
+    ".cursor-plugin",
+    ".kimi-plugin",
+    ".agents",
     "hooks",
+    "gemini-extension.json",
+    "GEMINI.md",
+    "AGENTS.md",
+    "plugin.json",
     "README.md",
     "LICENSE"
   ],
@@ -43,7 +52,8 @@
     "evals": "bun scripts/run-evals.ts",
     "retrieval-eval": "bun scripts/retrieval-eval.ts",
     "sync-version": "bun scripts/sync-version.ts",
-    "gate": "bun run typecheck && bun run test && bun run build && bun scripts/validate-content.ts --check-manifest --check-docs && bun scripts/run-evals.ts && bun scripts/retrieval-eval.ts",
+    "gate": "bun run typecheck && bun run test && bun run build && bun scripts/validate-content.ts --check-manifest --check-docs && bun run verify-pack && bun scripts/run-evals.ts && bun scripts/retrieval-eval.ts",
+    "verify-pack": "npm pack --dry-run 2>&1 | grep -q 'ionivetech-mugiwara' && echo '✓ npm package clean' || (echo '✗ npm pack failed' && exit 1)",
     "prepack": "bun run build && bun run sync-version"
   },
   "keywords": [
@@ -66,6 +76,7 @@
   ],
   "devDependencies": {
     "@types/node": "^26.2.0",
+    "@vitest/coverage-v8": "^4.1.10",
     "typescript": "^7.0.2",
     "vitest": "^4.1.10"
   }

package/plugin.json

@@ -0,0 +1,15 @@
+{
+  "name": "mugiwara",
+  "description": "The Straw Hat crew of AI agents and skills: brainstorm, plan, execute, checkpoint, quality, gates, review, security, healing.",
+  "version": "0.5.3",
+  "author": {
+    "name": "ionive"
+  },
+  "license": "MIT",
+  "repository": "https://github.com/ionivetech/mugiwara",
+  "keywords": [
+    "agents",
+    "skills",
+    "workflow"
+  ]
+}

package/src/targets/opencode.ts

@@ -3,6 +3,43 @@ import { join } from 'node:path';
 import { stringifyFrontmatter, type FrontmatterData } from '../frontmatter.ts';
 import type { Target } from '../installer.ts';
 
+type CrewConfig = {
+  color: string;
+  temperature: number;
+  steps: number;
+  permission?: Record<string, string>;
+};
+
+const CREW: Record<string, CrewConfig> = {
+  'luffy-orchestrator': { color: '#ef4444', temperature: 0.2, steps: 15 },
+  'usopp-brainstorm': { color: '#f59e0b', temperature: 0.6, steps: 15 },
+  'nami-planner': { color: '#f97316', temperature: 0.2, steps: 15 },
+  'zoro-execution': { color: '#22c55e', temperature: 0.1, steps: 30 },
+  'chopper-checkpoint': { color: '#3b82f6', temperature: 0.1, permission: { edit: 'deny' }, steps: 15 },
+  'sanji-quality': { color: '#a855f7', temperature: 0.1, permission: { edit: 'deny' }, steps: 10 },
+  'franky-gates': { color: '#06b6d4', temperature: 0.1, permission: { edit: 'deny' }, steps: 10 },
+  'robin-reviewer': { color: '#8b5cf6', temperature: 0.2, permission: { edit: 'deny' }, steps: 15 },
+  'jinbe-security': { color: '#6366f1', temperature: 0.2, permission: { edit: 'deny' }, steps: 15 },
+  'brook-healing': { color: '#ec4899', temperature: 0.1, steps: 20 },
+  'skeptic-verifier': { color: '#64748b', temperature: 0.1, permission: { edit: 'deny' }, steps: 12 },
+  'eval-runner': { color: '#14b8a6', temperature: 0.2, steps: 15 },
+  'resume-coordinator': { color: '#d97706', temperature: 0.2, steps: 10 },
+  'memory-keeper': { color: '#d946ef', temperature: 0.2, steps: 8 },
+};
+
+function agentFrontmatter(name: string, description: string) {
+  const crew = CREW[name];
+  const lines = [`description: ${description}`, `mode: all`];
+  if (crew) {
+    lines.push(`color: '${crew.color}'`, `temperature: ${crew.temperature}`, `steps: ${crew.steps}`);
+    if (crew.permission) {
+      lines.push('permission:');
+      for (const [k, v] of Object.entries(crew.permission)) lines.push(`  ${k}: ${v}`);
+    }
+  }
+  return lines.join('\n');
+}
+
 export const target: Target = {
   id: 'opencode',
   label: 'opencode',
@@ -18,9 +55,8 @@ export const target: Target = {
     };
   },
   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) };
+    const fm = agentFrontmatter(data.name, data.description);
+    return { relPath: `${data.name}.md`, text: `---\n${fm}\n---\n${body}` };
   },
   refsDir({ scope, projectDir, home }, skillName: string) {
     const root = scope === 'global' ? join(home, '.config', 'opencode') : join(projectDir, '.opencode');

package/.opencode/commands/mugiwara-mode.md

@@ -1,6 +0,0 @@
----
-description: Set the mugiwara runtime mode (guided | semi | auto)
----
-Set mugiwara mode: $ARGUMENTS
-
-Valid levels: guided, semi, auto. If no level given, show the current mode. The flip applies from the next wave.

package/content/agents/using-mugiwara.md

@@ -1,44 +0,0 @@
----
-name: using-mugiwara
-description: Front-door router. Classifies missions, routes to specialist. Never implements.
-skills: mugiwara-workflow, mugiwara-orchestration, mugiwara-pr
----
-
-# Using Mugiwara (Front Door)
-
-The easy entry point to the crew. Say "use mugiwara" or invoke `using-mugiwara` — you do not need to remember agent names. Embodied inline by the main thread; returns the route, never dispatches a crew member.
-
-## Auto-activation
-
-The workflow auto-activates for non-trivial requests — you do NOT need to call `using-mugiwara` at session start. This agent is an OPTIONAL explicit router: use it for a "how do I use mugiwara?" explanation or to route a mission by hand. For ANY non-trivial request, check before responding: if the mugiwara workflow could apply, run it — invoke the skill and start Wave 0 triage. Do not skip the check ("this is just a question", "I'll just do this one thing first", "I can explore first"). Process first: the crew workflow, then the specialized skill.
-
-## Experience
-
-Front-door router, 20 years of triage. Abilities: fast 5-way classification, knowing exactly which specialist to send, no-implementation discipline.
-
-## What to do
-
-1. **If the user asks how mugiwara works** — summarize in a few lines: the crew (Luffy gates, Nami plans, Zoro executes, Chopper audits, Brook heals), the workspace (`.mugiwara/`), and that every non-trivial mission starts with Luffy triage. Point to `mugiwara-workflow` for the full pipeline.
-2. **If the user gives a mission or task** — classify it (Trivial / Explicit / Exploratory / Open-ended / Ambiguous) and route:
-   - Clear, small, well-understood → route to `nami-planner` directly (or `zoro-execution` if a plan already exists).
-   - Vague idea, needs direction, research, or options → route to `usopp-brainstorm`.
-   - Anything else / not sure → route to `luffy-orchestrator` (full 5-way triage + check-ins).
-   - Specialized asks map directly: review → `robin-reviewer`, security → `jinbe-security`, fix failures → `brook-healing`, audit → `chopper-checkpoint`, resume → `resume-coordinator`, past lessons → `memory-keeper`.
-3. **Record the route** in the decision log (`.mugiwara/logs/YYYY-MM-DD-<mission>.md`) with a one-line reason — the harness stays coherent even when the entry was `using-mugiwara`. Read the active mode from `.mugiwara/config` (project then global config, missing = guided) and mention it in the route record so the session starts on the right level. Never write into the plan doc.
-
-## Rules
-
-1. Follow `mugiwara-workflow` and `mugiwara-orchestration` for the pipeline; this agent only routes.
-2. Never start implementation yourself — you are the front door, not a doer.
-3. Ambiguous → default to `luffy-orchestrator`, never guess a specialist.
-4. Direct calls do not skip Luffy's check-ins on the mission that follows.
-
-## Output
-
-Route decision + reason, written to the decision log (`.mugiwara/logs/YYYY-MM-DD-<mission>.md`). If no mission yet, a short "how to use" summary to the user.
-
-## Red flags
-
-- Implementing code instead of routing.
-- Guessing a specialist for an ambiguous request instead of sending it to Luffy.
-- Starting a mission without recording the route.

package/content/skills/mugiwara-proof-order/references/proof-order-examples.md

@@ -1,62 +0,0 @@
-# Proof Order Examples
-
-The test's proof value comes from WHEN it runs, not that it exists.
-
-## Why order matters
-
-```
-❌ Write implementation → Write test → Test passes immediately
-   The test never demonstrated it could catch the bug.
-   You cannot prove the test is testing the right thing.
-
-✅ Write test (red) → Watch it fail → Write implementation → Test passes (green)
-   The red phase proves the test catches the absence of the feature.
-   The green phase proves the feature satisfies the test.
-```
-
-## Example: password validation
-
-```ts
-// RED — test first, watch it fail
-describe('validatePassword', () => {
-  it('rejects passwords shorter than 8 characters', () => {
-    expect(validatePassword('short')).toBe(false);
-  });
-});
-
-// FAIL: validatePassword is not defined
-
-// GREEN — minimal impl
-function validatePassword(pw: string): boolean {
-  return pw.length >= 8;
-}
-
-// REFACTOR — while green
-function validatePassword(pw: string): boolean {
-  if (pw.length < 8) return false;
-  if (!/[A-Z]/.test(pw)) return false;
-  if (!/[0-9]/.test(pw)) return false;
-  return true;
-}
-```
-
-## Anti-pattern: test after implementation
-
-```ts
-// Code already written, then test added later:
-function formatCurrency(amount: number): string {
-  return `$${amount.toFixed(2)}`;
-}
-
-// Test passes immediately — proves nothing:
-it('formats currency', () => {
-  expect(formatCurrency(10)).toBe('$10.00'); // green on first run
-});
-```
-
-The fix: comment out the implementation, watch the test fail, then uncomment.
-If the test still passes with implementation removed, the test is wrong.
-
-## Rule
-
-A test that passes on first run has proven nothing. Discard the implementation and redo test-first, or comment it out and prove the test actually fails before restoring.

package/evals/cases/routing-proof-order.json

@@ -1,25 +0,0 @@
-{
-  "name": "routing-proof-order",
-  "skill": "mugiwara-proof-order",
-  "trigger": {
-    "positive": [
-      { "prompt": "write the test first before implementing the function", "top_k": 3 },
-      { "prompt": "use TDD — red green refactor for this feature", "top_k": 3 },
-      { "prompt": "prove the behavior with a failing test, then implement", "top_k": 3 }
-    ],
-    "negative": [
-      { "prompt": "run the existing unit test suite that was written last week" },
-      { "prompt": "run the acceptance tests defined by the user" }
-    ]
-  },
-  "behavioral": [
-    {
-      "task": "Implement a new utility function. Write the test first, then the implementation, then refactor.",
-      "rubric": [
-        "follows RED-GREEN-REFACTOR discipline",
-        "writes the test before the implementation",
-        "one test = one behavior"
-      ]
-    }
-  ]
-}