@ionivetech/mugiwara 0.2.0 → 0.4.0

package/src/cli.ts

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
 // src/cli.ts
-import { existsSync, readFileSync, readdirSync, realpathSync, rmSync } from 'node:fs';
+import { existsSync, readFileSync, realpathSync, rmSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { join, resolve } from 'node:path';
+import { 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 { installTo, removeInstalled, VERSION } from './installer.ts';
 import { manifestPath, readManifest, writeManifest, type Scope } from './manifest.ts';
-import { parseFrontmatter } from './frontmatter.ts';
+import { resetMission } from './mission.ts';
 
 const str = (v: FlagValue): string | undefined => (typeof v === 'string' ? v : undefined);
 const flag = (v: FlagValue): boolean => v === true;
@@ -23,11 +23,19 @@ export async function run(argv: string[]): Promise<void> {
     case 'update': return install({ ...flags, force: true });
     case 'uninstall': return uninstall(flags);
     case 'list': return list(flags);
-    case 'skills': return skills();
+    case 'reset': return resetCmd(flags);
     default: throw new Error(`Unknown command: ${command}`);
   }
 }
 
+function resetCmd(flags: Args['flags']): void {
+  const projectDir = resolve(str(flags.project) ?? process.cwd());
+  const { removed, kept } = resetMission(projectDir, flag(flags.keepLogs));
+  if (removed.length) console.log(`removed: ${removed.join(', ')}`);
+  else console.log('nothing to remove.');
+  if (kept.length) console.log(`kept: ${kept.join(', ')}`);
+}
+
 async function resolveOptions(flags: Args['flags']): Promise<{ scope: Scope; projectDir: string; targetIds: string[] }> {
   const interactive = !flag(flags.yes);
   const rl = interactive ? createRl() : null;
@@ -126,19 +134,6 @@ function list(flags: Args['flags']): void {
   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
 
@@ -147,7 +142,7 @@ Usage:
   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 reset         wipe mission state (spec/plans/results/review/issues[/logs])
   mugiwara --help        this help
   mugiwara --version     print version
 
@@ -157,7 +152,8 @@ Flags:
   --target <ids|all>     comma-separated: ${TARGET_IDS.join(', ')}
   --yes, -y              non-interactive (needs --global/--project, --target)
   --force                overwrite differing files (with backup)
-  --dry-run              print actions without writing`);
+  --dry-run              print actions without writing
+  --keep-logs            with reset: keep .mugiwara/logs (lessons ledger survives)`);
 }
 
 let entry = process.argv[1] !== undefined ? resolve(process.argv[1]) : undefined;

package/src/installer.ts

@@ -5,7 +5,12 @@ 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 ContentItem = {
+  name: string;
+  data: FrontmatterData;
+  body: string;
+  refs: { relPath: string; text: string }[];
+};
 
 export type InstallOptions = {
   scope: Scope;
@@ -28,9 +33,13 @@ export interface Target {
   id: string;
   label: string;
   native: boolean;
+  tier?: 1 | 2 | 3;
   paths(opts: { scope: Scope; projectDir: string; home: string }): { skillsDir: string; agentsDir: string };
   transformSkill(data: FrontmatterData, body: string): TransformOut;
   transformAgent(data: FrontmatterData, body: string): TransformOut;
+  refsDir?(opts: { scope: Scope; projectDir: string; home: string }, skillName: string): string;
+  transformSkillFull?(data: FrontmatterData, body: string): TransformOut | null;
+  transformAgentFull?(data: FrontmatterData, body: string): TransformOut | null;
   postInstall?(opts: { scope: Scope; projectDir: string; home: string; dryRun: boolean; files: string[] }): { written: string[]; notes: string[] };
 }
 
@@ -43,17 +52,24 @@ export function collectContent(): { skills: ContentItem[]; agents: ContentItem[]
     .filter(e => e.isDirectory()).map(e => e.name);
   const skills = skillNames.map(name => {
     const { data, body } = parseFrontmatter(readFileSync(join(CONTENT_DIR, 'skills', name, 'SKILL.md'), 'utf8'));
-    return { name, data, body };
+    return { name, data, body, refs: collectRefs(join(CONTENT_DIR, 'skills', name)) };
   });
   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 { name: f.replace(/\.md$/, ''), data, body, refs: [] as { relPath: string; text: string }[] };
     });
   return { skills, agents };
 }
 
+function collectRefs(skillDir: string): { relPath: string; text: string }[] {
+  const refsDir = join(skillDir, 'references');
+  if (!existsSync(refsDir)) return [];
+  return readdirSync(refsDir, { recursive: true }).map(f => String(f)).filter(f => f.endsWith('.md'))
+    .map(rel => ({ relPath: rel, text: readFileSync(join(refsDir, rel), 'utf8') }));
+}
+
 export function installTo(target: Target, opts: InstallOptions): InstallResult {
   const { scope, projectDir, dryRun = false, force = false } = opts;
   const home = opts.home ?? homedir();
@@ -82,10 +98,22 @@ export function installTo(target: Target, opts: InstallOptions): InstallResult {
   for (const s of skills) {
     const out = target.transformSkill(s.data, s.body);
     if (out) writeOne(join(dirs.skillsDir, out.relPath), out.text);
+    if (target.transformSkillFull) {
+      const full = target.transformSkillFull(s.data, s.body);
+      if (full && target.refsDir) writeOne(join(target.refsDir({ scope, projectDir, home }, s.name), full.relPath), full.text);
+    }
+    if (s.refs.length && target.refsDir) {
+      const refsRoot = target.refsDir({ scope, projectDir, home }, s.name);
+      for (const r of s.refs) writeOne(join(refsRoot, r.relPath), r.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.transformAgentFull) {
+      const full = target.transformAgentFull(a.data, a.body);
+      if (full && target.refsDir) writeOne(join(target.refsDir({ scope, projectDir, home }, a.name), full.relPath), full.text);
+    }
   }
 
   if (target.postInstall) {

package/src/mission.ts

@@ -0,0 +1,25 @@
+// src/mission.ts
+// Mission-state helpers for the mugiwara CLI (installer + reset only).
+import { existsSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+
+export function resetMission(projectDir: string, keepLogs: boolean): { removed: string[]; kept: string[] } {
+  const root = join(projectDir, '.mugiwara');
+  if (!existsSync(root)) return { removed: [], kept: [] };
+  const removed: string[] = [];
+  const kept: string[] = [];
+  for (const dir of ['spec', 'plans', 'results', 'review', 'issues']) {
+    const p = join(root, dir);
+    if (existsSync(p)) { rmSync(p, { recursive: true, force: true }); removed.push(dir); }
+  }
+  if (!keepLogs) {
+    const p = join(root, 'logs');
+    if (existsSync(p)) { rmSync(p, { recursive: true, force: true }); removed.push('logs'); }
+  } else if (existsSync(join(root, 'logs'))) {
+    kept.push('logs');
+  }
+  for (const f of ['config', 'manifest.json', 'backup']) {
+    if (existsSync(join(root, f))) kept.push(f);
+  }
+  return { removed, kept };
+}

package/src/targets/claude.ts

@@ -1,8 +1,13 @@
 // src/targets/claude.ts
-import { join } from 'node:path';
+import { existsSync, readFileSync, mkdirSync, copyFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { stringifyFrontmatter, type FrontmatterData } from '../frontmatter.ts';
 import type { Target } from '../installer.ts';
 
+const here = dirname(fileURLToPath(import.meta.url));
+const HOOK_SRC = join(here, '..', '..', 'hooks', 'session-start.ts');
+
 export const target: Target = {
   id: 'claude',
   label: 'Claude Code',
@@ -22,4 +27,20 @@ export const target: Target = {
     if (data.tools) fm.tools = data.tools;
     return { relPath: `${data.name}.md`, text: stringifyFrontmatter(fm, body) };
   },
+  refsDir({ scope, projectDir, home }, skillName: string) {
+    const root = scope === 'global' ? join(home, '.claude') : join(projectDir, '.claude');
+    return join(root, 'skills', skillName, 'references');
+  },
+  postInstall({ scope, projectDir, home, dryRun }) {
+    // Wire the SessionStart hook (inline doctrine) into the installed .claude dir.
+    const root = scope === 'global' ? join(home, '.claude') : join(projectDir, '.claude');
+    const hookFile = join(root, 'hooks', 'session-start.ts');
+    if (dryRun) return { written: [], notes: [] };
+    if (existsSync(HOOK_SRC) && !existsSync(hookFile)) {
+      mkdirSync(dirname(hookFile), { recursive: true });
+      copyFileSync(HOOK_SRC, hookFile);
+      return { written: [hookFile], notes: [] };
+    }
+    return { written: [], notes: [] };
+  },
 };

package/src/targets/codex.ts

@@ -6,5 +6,5 @@ export const target = makeGeneric({
   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.',
+  bootstrapPointer: 'Mugiwara crew installed in .codex/mugiwara/ — read .codex/mugiwara/mugiwara-workflow.md to run the pipeline inline in the main conversation.',
 });

package/src/targets/copilot.ts

@@ -1,6 +1,7 @@
 // src/targets/copilot.ts
 import { join } from 'node:path';
 import { stringifyFrontmatter, type FrontmatterData } from '../frontmatter.ts';
+import type { Scope } from '../manifest.ts';
 import type { Target } from '../installer.ts';
 
 export const target: Target = {
@@ -23,4 +24,7 @@ export const target: Target = {
       text: stringifyFrontmatter({ name: data.name, description: data.description }, body),
     };
   },
+  refsDir(_opts: { scope: Scope; projectDir: string; home: string }, skillName: string) {
+    return join(_opts.projectDir, '.mugiwara', 'refs', skillName);
+  },
 };

package/src/targets/gemini.ts

@@ -6,5 +6,5 @@ export const target = makeGeneric({
   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.',
+  bootstrapPointer: 'Mugiwara crew installed in .gemini/mugiwara/ — read .gemini/mugiwara/mugiwara-workflow.md to run the pipeline inline in the main conversation.',
 });

package/src/targets/generic.ts

@@ -1,6 +1,7 @@
 // src/targets/generic.ts
 import { existsSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
+import type { Scope } from '../manifest.ts';
 import type { Target } from '../installer.ts';
 
 export function makeGeneric(opts: {
@@ -9,23 +10,54 @@ export function makeGeneric(opts: {
   rulesDir: string;
   bootstrapFile: string | null;
   bootstrapPointer: string | null;
+  tier?: 2 | 3;
 }): Target {
-  const { id, label, rulesDir, bootstrapFile, bootstrapPointer } = opts;
+  const { id, label, rulesDir, bootstrapFile, bootstrapPointer, tier = bootstrapPointer ? 2 : 3 } = opts;
+  const stubOnly = tier === 3;
   return {
     id,
     label,
     native: false,
+    tier,
     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) {
+      if (stubOnly) {
+        // Stub: routing + pointer only. Full body lands in .mugiwara/refs/
+        // (outside the rules glob) so glob-loading harnesses stop eating ~40k
+        // tokens at session start. The agent reads the full file on demand.
+        return {
+          relPath: `${data.name}.md`,
+          text: `# ${data.name}\n\n> ${data.description}\n\n## Skip when\n\nFull skill: \`${data.name}\` — read \`.mugiwara/refs/${data.name}.md\` when the crew invokes this role.`,
+        };
+      }
+      return { relPath: `${data.name}.md`, text: `# ${data.name}\n\n> ${data.description}\n\n${body}` };
+    },
+    transformSkillFull(data, body) {
+      if (!stubOnly) return null;
       return { relPath: `${data.name}.md`, text: `# ${data.name}\n\n> ${data.description}\n\n${body}` };
     },
     transformAgent(data, body) {
+      if (stubOnly) {
+        return {
+          relPath: `agent-${data.name}.md`,
+          text: `# Agent: ${data.name}\n\n> ${data.description}\n\nSkills: ${data.skills ?? ''}. Read \`.mugiwara/refs/${data.name}.md\` when embodying this role.`,
+        };
+      }
       return { relPath: `agent-${data.name}.md`, text: `# Agent: ${data.name}\n\n> ${data.description}\n\nSkills used: ${data.skills ?? ''}\n\n${body}` };
     },
+    transformAgentFull(data, body) {
+      if (!stubOnly) return null;
+      return { relPath: `${data.name}.md`, text: `# Agent: ${data.name}\n\n> ${data.description}\n\nSkills used: ${data.skills ?? ''}\n\n${body}` };
+    },
+    refsDir({ projectDir }: { scope: Scope; projectDir: string; home: string }) {
+      // Keep reference detail outside the rules dir so the harness never
+      // glob-loads it; the skill names the path and the agent reads on demand.
+      return join(projectDir, '.mugiwara', 'refs');
+    },
     postInstall({ projectDir, dryRun }) {
       if (!bootstrapFile) return { written: [], notes: [] };
       const notes: string[] = [];

package/src/targets/kilo.ts

@@ -7,4 +7,5 @@ export const target = makeGeneric({
   rulesDir: '.kilo/rules',
   bootstrapFile: 'kilo.jsonc',
   bootstrapPointer: '{\n  "instructions": [\n    ".kilo/rules/*.md"\n  ]\n}',
+  tier: 3,
 });

package/src/targets/opencode.ts

@@ -22,4 +22,8 @@ export const target: Target = {
     if (data.tools) fm.tools = data.tools;
     return { relPath: `${data.name}.md`, text: stringifyFrontmatter(fm, body) };
   },
+  refsDir({ scope, projectDir, home }, skillName: string) {
+    const root = scope === 'global' ? join(home, '.config', 'opencode') : join(projectDir, '.opencode');
+    return join(root, 'skills', skillName, 'references');
+  },
 };