@ionivetech/mugiwara 0.6.0 → 0.6.1

package/src/cli.ts

@@ -7,15 +7,15 @@ import { fileURLToPath } 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 } from './installer.ts';
+import { installTo, removeInstalled, VERSION, ensureProjectGitignore } from './installer.ts';
 import { manifestPath, readManifest, writeManifest, type Scope } from './manifest.ts';
-import { resetMission } from './mission.ts';
+import { resetMission, archiveMission } from './mission.ts';
 
 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);
+  const { command, flags, _ } = parseArgs(argv);
   if (flag(flags.help) || command === 'help') return help();
   if (flag(flags.version)) { console.log(`mugiwara ${VERSION}`); return; }
   switch (command) {
@@ -24,6 +24,7 @@ export async function run(argv: string[]): Promise<void> {
     case 'uninstall': return uninstall(flags);
     case 'list': return list(flags);
     case 'reset': return resetCmd(flags);
+    case 'archive': return archive(flags, _);
     default: throw new Error(`Unknown command: ${command}`);
   }
 }
@@ -41,6 +42,17 @@ function resetCmd(flags: Args['flags']): void {
   if (result.kept.length) console.log(`kept: ${result.kept.join(', ')}`);
 }
 
+function archive(flags: Args['flags'], positionals: string[]): void {
+  const projectDir = resolve(str(flags.project) ?? process.cwd());
+  const mission = positionals[1];
+  if (!mission) { console.error('usage: mugiwara archive <mission> [--project <dir>] [--dry-run]'); process.exit(1); }
+  const result = archiveMission(projectDir, mission, { dryRun: flag(flags.dryRun) });
+  if (result.report) console.log(`archive target: ${result.report}`);
+  if (result.removed.length) console.log(`${flag(flags.dryRun) ? 'would remove' : 'removed'}: ${result.removed.join(', ')}`);
+  if (result.kept.length) console.log(`kept: ${result.kept.join(', ')}`);
+  if (result.index) console.log(`index updated: ${result.index}`);
+}
+
 async function resolveOptions(flags: Args['flags']): Promise<{ scope: Scope; projectDir: string; targetIds: string[] }> {
   const interactive = !flag(flags.yes);
   if (interactive && !process.stdin.isTTY) {
@@ -95,6 +107,10 @@ async function install(flags: Args['flags']): Promise<void> {
     allFiles.push(...r.written);
     allNotes.push(...r.notes);
   }
+  if (scope === 'project') {
+    const gi = ensureProjectGitignore(projectDir, { dryRun: flag(flags.dryRun) });
+    allNotes.push(...gi.notes);
+  }
   if (flag(flags.dryRun)) { console.log('\nDry run — nothing written.'); return; }
   const file = manifestPath({ scope, projectDir, home });
   const prev = readManifest(file);
@@ -182,6 +198,7 @@ Usage:
   mugiwara list          show installations
   mugiwara list --check  health check: show installations + missing files
   mugiwara reset         wipe mission state (spec/plans/results/review/issues[/logs])
+  mugiwara archive <m>    fold a closed mission's evidence into its report, then remove loose files
   mugiwara --help        this help
   mugiwara --version     print version
 

package/src/installer.ts

@@ -1,5 +1,5 @@
 // src/installer.ts
-import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, copyFileSync, rmSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, copyFileSync, rmSync, lstatSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
@@ -171,3 +171,39 @@ export function removeInstalled(manifest: { files: string[] }, { dryRun = false
   }
   return removed;
 }
+
+function assertNotSymlink(file: string): void {
+  if (!existsSync(file)) return;
+  try {
+    if (lstatSync(file).isSymbolicLink()) throw new Error(`refusing to follow symlink: ${file}`);
+  } catch (e) {
+    if ((e as { code?: string }).code === 'ENOENT') return;
+    throw e;
+  }
+}
+
+const GITIGNORE_MARKER = '# mugiwara';
+const GITIGNORE_BLOCK = `# mugiwara — audit trail is the product: commit reports/, results/, logs/, spec/, plans/.
+# Ignore session state and regenerated files.
+.mugiwara/state.json
+.mugiwara/state-*.json
+.mugiwara/config
+.mugiwara/continue.md
+.mugiwara/refs/
+`;
+
+export function ensureProjectGitignore(projectDir: string, opts: { dryRun?: boolean } = {}): { appended: boolean; notes: string[] } {
+  const { dryRun = false } = opts;
+  const path = join(projectDir, '.gitignore');
+  assertNotSymlink(path);
+  if (existsSync(path) && readFileSync(path, 'utf8').includes(GITIGNORE_MARKER)) {
+    return { appended: false, notes: [] };
+  }
+  const existing = existsSync(path) ? readFileSync(path, 'utf8') : '';
+  const separator = existing.length && !existing.endsWith('\n') ? '\n' : '';
+  if (!dryRun) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, existing + separator + GITIGNORE_BLOCK);
+  }
+  return { appended: true, notes: [`.gitignore ${dryRun ? 'would append' : 'appended'} mugiwara audit-trail block`] };
+}

package/src/mission.ts

@@ -1,6 +1,6 @@
 // src/mission.ts
 // Mission-state helpers for the mugiwara CLI (installer + reset only).
-import { existsSync, rmSync, readFileSync, readdirSync } from 'node:fs';
+import { existsSync, rmSync, readFileSync, readdirSync, mkdirSync, appendFileSync } from 'node:fs';
 import { join } from 'node:path';
 
 function activeActor(projectDir: string): string | null {
@@ -48,3 +48,113 @@ export function resetMission(projectDir: string, keepLogs: boolean, force?: bool
   }
   return { removed, kept };
 }
+
+export function archiveMission(projectDir: string, mission: string, opts: { dryRun?: boolean } = {}): { report: string | null; removed: string[]; kept: string[]; index?: string } {
+  const { dryRun = false } = opts;
+  const root = join(projectDir, '.mugiwara');
+  // mission allowlist — same as savepoint.sh / mission-report.sh. Dot-only
+  // names (".", "..") would resolve upward through join(...,"..") and let
+  // rmSync reach state.json/config outside the mission dir.
+  if (!mission || /[^a-zA-Z0-9._-]/.test(mission) || /^\.+$/.test(mission)) throw new Error(`invalid mission name "${mission}" (allowlist: [a-zA-Z0-9._-], not a dot-path)`);
+  const removed: string[] = [];
+  const kept: string[] = [];
+
+  // A file belongs to this mission when stripping the optional YYYY-MM-DD-
+  // prefix leaves `<mission>.md` or `<mission>-<suffix>.md`. Covers both the
+  // bare names and the date-prefixed names the prose writes (audit-trail.md).
+  const belongs = (f: string): boolean => {
+    const base = f.replace(/^\d{4}-\d{2}-\d{2}-/, '');
+    return base === `${mission}.md` || base.startsWith(`${mission}-`);
+  };
+
+  // locate the report (the archive target that must survive). Reports are
+  // date-prefixed (`reports/YYYY-MM-DD-<mission>.md`); compare the stripped
+  // mission name so `bar-foo.md` is not mistaken for mission `foo`.
+  let report: string | null = null;
+  const reportsDir = join(root, 'reports');
+  if (existsSync(reportsDir)) {
+    const f = readdirSync(reportsDir).find(n => {
+      const m = n.match(/^(\d{4}-\d{2}-\d{2})-(.+)\.md$/);
+      return !!m && m[2] === mission;
+    });
+    if (f) report = join('reports', f);
+  }
+
+  // remove per-mission wave intermediates from results/<mission>/, EXCEPT
+  // 06-closure.md and 07-pr-verdict.md (PR material + closure stay)
+  const resultsDir = join(root, 'results', mission);
+  if (existsSync(resultsDir)) {
+    for (const f of readdirSync(resultsDir)) {
+      if (f === '06-closure.md' || f === '07-pr-verdict.md') { kept.push(join('results', mission, f)); continue; }
+      const p = join(resultsDir, f);
+      if (!dryRun) rmSync(p, { recursive: true, force: true });
+      removed.push(join('results', mission, f));
+    }
+  }
+
+  // spec, review, issues, per-mission decision log — bare + date-prefixed
+  const specDir = join(root, 'spec');
+  if (existsSync(specDir)) {
+    for (const f of readdirSync(specDir)) {
+      if (!belongs(f)) continue;
+      const p = join(specDir, f);
+      if (!dryRun) rmSync(p);
+      removed.push(join('spec', f));
+    }
+  }
+
+  for (const dir of ['review', 'issues']) {
+    const d = join(root, dir);
+    if (!existsSync(d)) continue;
+    for (const f of readdirSync(d)) {
+      if (!belongs(f)) continue;
+      const p = join(d, f);
+      if (!dryRun) rmSync(p, { force: true });
+      removed.push(join(dir, f));
+    }
+  }
+
+  const logsDir = join(root, 'logs');
+  if (existsSync(logsDir)) {
+    for (const f of readdirSync(logsDir)) {
+      if (!belongs(f)) continue;
+      const p = join(logsDir, f);
+      if (!dryRun) rmSync(p);
+      removed.push(join('logs', f));
+    }
+  }
+
+  // continue.md is a session handoff — only remove it if it belongs to THIS
+  // mission (its content references the mission name); otherwise leave it.
+  const cont = join(root, 'continue.md');
+  if (existsSync(cont)) {
+    try {
+      if (readFileSync(cont, 'utf8').includes(mission)) {
+        if (!dryRun) rmSync(cont);
+        removed.push('continue.md');
+      }
+    } catch { /* unreadable — leave it */ }
+  }
+
+  // kept: report + the audit-trail survivors
+  if (report) kept.push(report);
+  for (const k of ['plans', 'config', 'state.json', join('logs', 'lessons.md')]) {
+    if (existsSync(join(root, k))) kept.push(k);
+  }
+
+  // summary index: append one line per archived mission (retention aid),
+  // idempotently — never duplicate a line for an already-indexed mission.
+  let index: string | undefined;
+  const indexFile = join(root, 'reports', 'index.md');
+  const line = `- ${mission} — ${new Date().toISOString().slice(0, 10)}${report ? ` → ${report}` : ''}\n`;
+  if (!dryRun) {
+    mkdirSync(join(root, 'reports'), { recursive: true });
+    const existing = existsSync(indexFile) ? readFileSync(indexFile, 'utf8') : '';
+    if (!existing.split(/\r?\n/).some(l => l.startsWith(`- ${mission} —`))) {
+      const header = existing ? '' : '# Mission index\n\n';
+      appendFileSync(indexFile, header + line);
+    }
+    index = join('reports', 'index.md');
+  }
+  return { report, removed, kept, index };
+}

package/src/targets/claude.ts

@@ -6,9 +6,17 @@ 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');
+const HOOKS_SRC = join(here, '..', '..', 'hooks');
 const COMMANDS_SRC = join(here, '..', '..', '.claude', 'commands');
 
+// Claude Code has no path-scoped permission. write-scope maps to a partial
+// `tools:` list: artifacts agents lose Edit (cannot modify existing source)
+// but keep Write (must create .mugiwara/**); source agents get the default set.
+function toolsFromScope(scope?: string): string | undefined {
+  if (scope === 'artifacts') return 'Read, Grep, Glob, Write, Bash, WebFetch, WebSearch';
+  return undefined;
+}
+
 export const target: Target = {
   id: 'claude',
   label: 'Claude Code',
@@ -27,6 +35,10 @@ 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;
+    else {
+      const generated = toolsFromScope(data['write-scope']);
+      if (generated) fm.tools = generated;
+    }
     return { relPath: `${data.name}.md`, text: stringifyFrontmatter(fm, body) };
   },
   refsDir({ scope, projectDir, home }, skillName: string) {
@@ -34,17 +46,24 @@ export const target: Target = {
     return join(root, 'skills', skillName, 'references');
   },
   postInstall({ scope, projectDir, home, dryRun }) {
-    // Wire the SessionStart hook (inline doctrine) into the installed .claude dir.
+    // Wire hook scripts (SessionStart + UserPromptSubmit) into the installed .claude dir.
     const root = scope === 'global' ? join(home, '.claude') : join(projectDir, '.claude');
-    const hookFile = join(root, 'hooks', 'session-start.ts');
     const written: string[] = [];
     const notes: string[] = [];
     if (dryRun) return { written: [], notes: [] };
-    if (existsSync(HOOK_SRC) && !existsSync(hookFile)) {
-      mkdirSync(dirname(hookFile), { recursive: true });
-      copyFileSync(HOOK_SRC, hookFile);
-      chmodSync(hookFile, 0o755);
-      written.push(hookFile);
+    if (existsSync(HOOKS_SRC)) {
+      for (const f of readdirSync(HOOKS_SRC)) {
+        if (!f.endsWith('.ts')) continue;
+        const dst = join(root, 'hooks', f);
+        if (!existsSync(dst)) {
+          mkdirSync(dirname(dst), { recursive: true });
+          copyFileSync(join(HOOKS_SRC, f), dst);
+          // /bin/sh executes hooks via shebang — a non-executable copy is a
+          // "Permission denied" at first user prompt. chmod every hook file.
+          chmodSync(dst, 0o755);
+          written.push(dst);
+        }
+      }
     }
     // Port the /mugiwara commands into the installed .claude dir.
     if (existsSync(COMMANDS_SRC)) {