@nfinitmonkeys/clan-engine 0.1.0

package/dist/templates.js

@@ -0,0 +1,303 @@
+/**
+ * THE authoritative template set. This is the single source of truth for every
+ * file the engine writes into a node — the whole point of the engine is that
+ * the published CLIs AND the internal fleet tooling both render from here, so
+ * they can never drift again.
+ *
+ * Every generated file carries a marker (`generated-by: clan-engine@<v>` +
+ * `layout: <n>`) so reconciliation can distinguish our output (safe to update)
+ * from a user's hand-written file at the same path (must be backed up).
+ */
+import { ENGINE_VERSION, LAYOUT_VERSION, GENERATED_BY } from './types.js';
+/** Frontmatter marker lines (inside a YAML block). */
+export function markerLines() {
+    return `${GENERATED_BY}: ${ENGINE_VERSION}\nlayout: ${LAYOUT_VERSION}`;
+}
+/** Frontmatter keys that mean "this file is engine-managed" — our own marker
+ *  plus predecessor markers so a first engine pass over a clan-ready-managed
+ *  repo ADOPTS (updates) the files instead of backup-replacing all of them. */
+const MANAGED_KEYS = [GENERATED_BY, 'generated-by'];
+/** Extract the leading YAML frontmatter block (between the first two `---`). */
+function frontmatterBlock(content) {
+    if (!content.startsWith('---'))
+        return null;
+    const end = content.indexOf('\n---', 3);
+    return end === -1 ? null : content.slice(3, end);
+}
+/**
+ * True only when the file carries an engine (or predecessor) marker as a real
+ * frontmatter KEY — not merely a substring somewhere in the body. This stops a
+ * user file that happens to mention "clan-engine:" in prose from being
+ * misclassified as ours and silently overwritten.
+ */
+export function hasManagedMarker(content) {
+    const fm = frontmatterBlock(content);
+    if (fm === null)
+        return false;
+    return fm.split('\n').some(line => {
+        const m = /^([A-Za-z0-9_-]+):/.exec(line.trim());
+        return !!m && MANAGED_KEYS.includes(m[1]);
+    });
+}
+/** Geo-tier HTML-comment marker for CLAUDE.md (declared identity, never inferred). */
+export function geoTierMarker(tier) {
+    return `<!-- geo-tier: ${tier} -->`;
+}
+/**
+ * Find a REAL top-level geo-tier declaration: a standalone line (its trimmed
+ * content is exactly the marker) that is NOT inside a fenced code block. A
+ * marker mentioned inside ``` fences or in prose is documentation, not a
+ * declaration, and must be ignored (else tier is mis-detected and retier
+ * corrupts the user's docs). Returns the declared tier + the exact line, or null.
+ */
+export function findGeoTierMarker(content) {
+    const lineRe = /^<!--\s*geo-tier:\s*(clan|district|jungle|biome)\s*-->$/;
+    let inFence = false;
+    for (const raw of content.split('\n')) {
+        const trimmed = raw.trim();
+        if (/^(```|~~~)/.test(trimmed)) {
+            inFence = !inFence;
+            continue;
+        }
+        if (inFence)
+            continue;
+        const m = lineRe.exec(trimmed);
+        if (m)
+            return { tier: m[1], line: raw };
+    }
+    return null;
+}
+// ─── CLAUDE.md identity block ───────────────────────────────────────────────
+/** The identity block prepended to CLAUDE.md when the file is created fresh.
+ *  When CLAUDE.md already exists we only ensure the geo-tier marker line
+ *  (reconcile handles that) — we never rewrite a user's prose. */
+export function claudeMdIdentity(i) {
+    const noun = i.tier;
+    const idLine = i.alphaId ? ` (\`${i.alphaId}\`)` : '';
+    return `${geoTierMarker(i.tier)}
+# Identity
+
+You are operating as **${i.alphaName}** — the Alpha of ${noun} **${i.name}**${idLine}.
+
+This repo is a **${noun.toUpperCase()}** node in the Nfinit Monkeys geography
+(Biome ⊃ Jungle ⊃ District ⊃ Clan). Identity is DECLARED here, never inferred.
+
+## Tool defaults
+
+- Default MCP prefix: \`mcp__jungle-local__*\` (this node's voice).
+- The Alpha's brain (persistent memory) lives under \`.brain/\` — hydrated at
+  session start by the SessionStart hook.
+
+## Scope
+
+Routine work here is node-local. Slash commands are tier-named:
+\`/${noun}:status\` · \`/${noun}:inbox\` · \`/${noun}:log\` · \`/${noun}:policies\` · \`/${noun}:request\`.
+`;
+}
+// ─── awareness skill (SKILL.md directory format — loadable) ─────────────────
+function awarenessSkill(i) {
+    const noun = i.tier;
+    const modeLine = i.mode === 'connected'
+        ? `- **Mode:** connected${i.jungle?.apiUrl ? ` to ${i.jungle.apiUrl}` : ''}${i.alphaId ? `\n- **Alpha ID:** \`${i.alphaId}\`` : ''}`
+        : `- **Mode:** standalone — no Jungle, no approval queue. The developer IS the Human Council.`;
+    const governance = i.mode === 'connected'
+        ? `## Governance (connected)
+
+Alphas **propose**, humans **approve**. Sensitive actions go through a gated
+approval flow (\`request_approval\` → Human Council reviews in BOSS → execute →
+logged). To change this node's permissions, tell the user to message the Alpha
+in natural language — it will propose the change for approval.`
+        : `## Governance (standalone)
+
+There is no remote council. The developer at this terminal IS the council. When
+they want to change a policy: confirm it, edit \`.jungle/config.yaml\`, restart
+the Alpha. Explicit confirmation IS the approval — never mutate config silently.`;
+    const usingExisting = `## Use what this project already has
+
+If the user already has agents, skills, or slash commands (e.g. from other
+tools), PREFER them where they overlap instead of duplicating. The clan is a
+teammate to the existing setup, not a replacement — check \`.clan/inventory.json\`
+(written by the engine) for what's available, and route to it by name.`;
+    return {
+        path: '.claude/skills/clan-awareness/SKILL.md',
+        managed: true,
+        content: `---
+name: clan-awareness
+description: This project is a ${noun} node (${i.alphaName} / ${i.name}) run via @nfinitmonkeys/clan — how to answer status, governance, and "talk to the Alpha" questions
+${markerLines()}
+---
+
+# Clan Awareness — ${i.name}
+
+You are inside a **${noun}** node run via \`@nfinitmonkeys/clan\`, with its own
+Alpha (**${i.alphaName}**), policies, and accumulated memory (a "brain").
+
+## Working *as* the Alpha
+
+In this repo you act **as ${i.alphaName}**. But ${i.alphaName} is bigger than one
+chat: it has a **brain** (\`npx -y @nfinitmonkeys/clan brain "…"\` — persistent
+memory), an **inbox** (\`npx -y @nfinitmonkeys/clan talk "…"\`), and an
+**autonomous loop** (\`npx -y @nfinitmonkeys/clan start\`). If the user says "I
+want to talk to the Alpha," don't say "you already are" — point them to those.
+
+## This node
+
+- **Name:** ${i.name}
+- **Alpha:** ${i.alphaName}
+- **Tier:** ${noun}
+${modeLine}
+
+## Slash commands (tier-named)
+
+\`/${noun}:status\` · \`/${noun}:inbox\` · \`/${noun}:log\` · \`/${noun}:policies\` · \`/${noun}:request\`
+
+If the user types a different tier's command (e.g. \`/clan:status\` in a
+district), point them to the right one — don't silently alias.
+
+${usingExisting}
+
+${governance}
+`,
+    };
+}
+// ─── tier-named command pack ────────────────────────────────────────────────
+function cmd(tier, name, description, body) {
+    return {
+        path: `.claude/commands/${tier}/${name}.md`,
+        managed: true,
+        content: `---
+name: ${tier}:${name}
+description: ${description}
+${markerLines()}
+---
+
+${body}
+`,
+    };
+}
+function commandPack(i) {
+    const t = i.tier;
+    const files = [
+        cmd(t, 'status', `Show this ${t}'s live status — identity, policies, inbox, telemetry`, `Run the clan status command and present it as a clean dashboard. If MCP is wired, you may also call \`mcp__jungle-local__jungle_whoami\` and \`mcp__jungle-local__jungle_get_self\`.
+
+\`\`\`bash
+npx -y @nfinitmonkeys/clan status
+\`\`\``),
+        cmd(t, 'policies', `Show this ${t}'s autonomous / gated / denied actions`, `\`\`\`bash
+npx -y @nfinitmonkeys/clan policies
+\`\`\`
+
+Explain what each action bucket means for this project. To change one in
+connected mode, tell the user to message the Alpha; standalone, edit
+\`.jungle/config.yaml\` directly.`),
+        cmd(t, 'request', `Propose a policy or governance change for this ${t}`, i.mode === 'connected'
+            ? `Compose the natural-language request the user sends to the Alpha (which files a \`request_approval\` with actionType=policy_change). Confirm the target bucket + rationale, then:
+
+\`\`\`bash
+npx -y @nfinitmonkeys/clan talk "your request here"
+\`\`\``
+            : `Standalone — the user is the approver. Confirm the change (actionType, bucket, why), edit \`.jungle/config.yaml\`, restart the Alpha. Never fabricate a remote approval flow.`),
+    ];
+    if (i.mode === 'connected') {
+        files.push(cmd(t, 'inbox', `View recent messages in ${i.alphaName}'s inbox`, `\`\`\`bash
+npx -y @nfinitmonkeys/clan inbox
+\`\`\`
+
+Summarize pending (●) vs read (○); highlight anything urgent. Requires a Jungle
+connection.`), cmd(t, 'log', `Governance log — every policy change with who/when/why`, `\`\`\`bash
+npx -y @nfinitmonkeys/clan status --json 2>/dev/null | node -e "let s='';process.stdin.on('data',d=>s+=d).on('end',()=>{try{const j=JSON.parse(s);console.log(JSON.stringify((j.self&&j.self.governanceLog||[]).slice(0,10),null,2))}catch{console.log('[]')}})"
+\`\`\`
+
+Format as a timeline (newest first): timestamp, operation, action, requester,
+approver, rationale.`), cmd(t, 'health', `Probe this ${t}'s health and report it to the Jungle`, `\`\`\`bash
+npx -y @nfinitmonkeys/clan health
+\`\`\`
+
+Probes come from \`.jungle/config.yaml\` under \`health:\`. Summarize each check
+(ok / degraded / down) after it reports.`));
+    }
+    return files;
+}
+// ─── brain scaffold (canonical layout — <brainRoot>/wiki + .brain-meta.json) ─
+/** Where the brain lives, per tier (matches the fleet's clan-ready layout so
+ *  the engine never puts .brain/ where a district/jungle expects its vault). */
+export function brainRoot(i) {
+    if (i.tier === 'district')
+        return '.district/brain';
+    if (i.tier === 'jungle')
+        return `.brains/${i.alphaName.toLowerCase()}`;
+    return '.brain';
+}
+export function brainScaffold(i, today) {
+    const root = brainRoot(i);
+    const files = [];
+    const push = (rel, content, managed = true) => files.push({ path: `${root}/${rel}`, content, managed });
+    push('.brain-meta.json', JSON.stringify({
+        schemaVersion: '1.0',
+        layoutVersion: LAYOUT_VERSION,
+        generatedBy: `${GENERATED_BY}@${ENGINE_VERSION}`,
+        alphaId: i.alphaId ?? null,
+        createdAt: today,
+    }, null, 2) + '\n');
+    push('CLAUDE.md', `# ${i.alphaName}'s Brain — ${i.name} Memory Vault\n\nPersistent, compounding memory. Read \`wiki/hot.md\` first.\n\n| Field | Value |\n|---|---|\n| alphaId | \`${i.alphaId ?? '(unset)'}\` |\n| alphaName | ${i.alphaName} |\n| node | ${i.name} |\n| tier | ${i.tier} |\n`);
+    push('wiki/identity.md', `---\nname: Identity — ${i.alphaName}\ndescription: Who I am\ntype: identity\nupdated: ${today}\n---\n\n# ${i.alphaName} — Alpha of ${i.name}\n\n| Field | Value |\n|---|---|\n| alphaId | \`${i.alphaId ?? '(unset)'}\` |\n| alphaName | **${i.alphaName}** |\n| node | ${i.name} |\n| geoTier | ${i.tier} |\n\n## Mission\n\n${i.description || `${i.alphaName} is the Alpha of ${i.name}.`}\n`);
+    push('wiki/hot.md', `---\nname: Hot Cache\ndescription: Recent context — read at session start\ntype: hot\nupdated: ${today}\n---\n\n# Hot Cache\n\nBrain scaffolded ${today} by ${GENERATED_BY}. Observations and decisions accumulate here.\n`);
+    push('wiki/index.md', `---\nname: Index\ntype: index\nupdated: ${today}\n---\n\n# Index\n\n- [[identity]] · [[hot]] · [[log]]\n- entities/ · concepts/ · decisions/ · observations/ · goals/ · relationships/ · questions/ · sources/\n`);
+    push('wiki/log.md', `---\nname: Action Log\ntype: log\nupdated: ${today}\n---\n\n# Action Log\n\n## ${today}\n- Brain vault scaffolded by ${GENERATED_BY}.\n`);
+    for (const cat of ['entities', 'concepts', 'decisions', 'observations', 'goals', 'relationships', 'questions', 'sources']) {
+        push(`wiki/${cat}/_index.md`, `---\nname: ${cat} — Index\ntype: domain-index\nupdated: ${today}\n---\n\n# ${cat}\n\n*Populates as ${i.alphaName} accumulates ${cat}.*\n`);
+    }
+    return files;
+}
+// ─── cross-platform SessionStart hook (Node, not bash) ──────────────────────
+/** The command wired into .claude/settings.json SessionStart. Relative (hooks
+ *  run at project root) + the script self-locates via import.meta, so it is
+ *  cwd- and OS-independent. Tier-aware because the brain root is. */
+export function hookCommand(i) {
+    return `node ${brainRoot(i)}/scripts/load-brain.mjs`;
+}
+/** Regex matching any load-brain hook command (bash or node, any brain root) —
+ *  used to detect + migrate a previously-wired hook. */
+export const LOAD_BRAIN_HOOK_RE = /load-brain\.(mjs|sh)/;
+export function loadBrainScript(i) {
+    const header = `# ${i.alphaName}'s brain — loaded at session start`;
+    const sub = `Persistent memory for ${i.name} (${i.tier}). Authoritative on identity, recent context, standing goals.`;
+    return {
+        path: `${brainRoot(i)}/scripts/load-brain.mjs`,
+        managed: false, // a runnable script; content-compare handles idempotency
+        chmod: 0o755,
+        content: `#!/usr/bin/env node
+// load-brain.mjs — hydrate ${i.alphaName}'s brain at session start (${GENERATED_BY}).
+// Cross-platform (macOS/Windows/Linux). Self-noops (exit 0, no output) with no brain.
+import { readFileSync, existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const wiki = join(dirname(dirname(fileURLToPath(import.meta.url))), 'wiki');
+if (!existsSync(wiki)) process.exit(0);
+
+const out = [${JSON.stringify(header)}, '', ${JSON.stringify(sub)}, '---'];
+for (const f of ['identity.md', 'hot.md']) {
+  const p = join(wiki, f);
+  if (existsSync(p)) { out.push('## From wiki/' + f, '', readFileSync(p, 'utf-8'), '---'); }
+}
+const today = new Date().toISOString().slice(0, 10);
+const obs = join(wiki, 'observations', today + '.md');
+if (existsSync(obs)) { out.push("## Today's observations", '', readFileSync(obs, 'utf-8')); }
+process.stdout.write(out.join('\\n') + '\\n');
+process.exit(0);
+`,
+    };
+}
+// ─── the full managed .claude surface for an identity ───────────────────────
+/**
+ * Every managed file the engine authors into .claude/ + .brain/ for one
+ * identity, EXCEPT the merge-based artifacts (.mcp.json, settings.json hook,
+ * CLAUDE.md) which reconcile handles specially because they touch user content.
+ */
+export function claudeSurface(i) {
+    return [awarenessSkill(i), ...commandPack(i), loadBrainScript(i)];
+}
+/** All tier command directories the engine owns — used to prune stale packs
+ *  from a different tier (e.g. a repo re-tiered clan → district). */
+export const ALL_TIER_DIRS = ['clan', 'district', 'jungle', 'biome'];

package/dist/types.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Shared contract for the clan-engine. Every module imports from here; nothing
+ * else is cross-imported, so the pieces stay independently testable.
+ */
+/** Engine + layout versions. LAYOUT_VERSION is stamped into every generated
+ *  file's marker so a future engine can tell "my old output" from "my current
+ *  output" and run migrations. Bump LAYOUT_VERSION when the template SHAPE
+ *  changes (a path moves, a format changes); bump ENGINE_VERSION freely. */
+export declare const ENGINE_VERSION = "0.1.0";
+export declare const LAYOUT_VERSION = 1;
+/** The marker key written into generated-file frontmatter / headers. */
+export declare const GENERATED_BY = "clan-engine";
+export type Tier = 'clan' | 'district' | 'jungle' | 'biome';
+export type Mode = 'connected' | 'standalone';
+/** How the tier was decided (declared always wins over inferred). */
+export type TierSource = 'flag' | 'marker' | 'district-dir' | 'brains-dir' | 'default';
+export interface ClanIdentity {
+    /** Clan / node display name. */
+    name: string;
+    alphaName: string;
+    alphaId?: string;
+    description: string;
+    tier: Tier;
+    mode: Mode;
+    /** connected-mode credentials (drive .mcp.json). */
+    jungle?: {
+        apiUrl: string;
+        alphaId: string;
+        apiKey: string;
+        humanEmail?: string;
+    };
+}
+/** A file the templates want to exist, before reconciliation. */
+export interface GeneratedFile {
+    path: string;
+    content: string;
+    /** true when this file carries a clan-engine marker (so reconciliation can
+     *  tell our output from a user's hand-written file at the same path). */
+    managed: boolean;
+    /** POSIX chmod to apply after write (e.g. 0o755 for scripts). */
+    chmod?: number;
+}
+export type ActionKind = 'create' | 'update' | 'backup-replace' | 'merge' | 'append' | 'remove' | 'skip';
+export interface PlanAction {
+    kind: ActionKind;
+    path: string;
+    content?: string;
+    note: string;
+    chmod?: number;
+    /** why this action was chosen — surfaced in dry-run output. */
+    reason?: string;
+}
+export interface Plan {
+    identity: ClanIdentity;
+    actions: PlanAction[];
+    /** repo root the plan targets. */
+    repo: string;
+}
+/** One inventoried Claude Code asset the user already has. */
+export interface InventoryItem {
+    kind: 'agent' | 'skill' | 'command' | 'hook';
+    name: string;
+    path: string;
+    scope: 'project' | 'global';
+    description?: string;
+}
+export type NodeState = 'fresh' | 'partial' | 'current' | 'legacy' | 'drifted';
+export interface McpServerInfo {
+    name: string;
+    isJungle: boolean;
+    misnamed: boolean;
+}
+export interface InspectResult {
+    repo: string;
+    os: string;
+    isGit: boolean;
+    tier: Tier;
+    tierSource: TierSource;
+    mode: Mode;
+    identity?: ClanIdentity;
+    /** .jungle/config.yaml present + parsed? */
+    hasConfig: boolean;
+    configError?: string;
+    /** .mcp.json present? which servers? */
+    hasMcp: boolean;
+    mcpServers: McpServerInfo[];
+    /** the user's existing Claude Code assets (project + global). */
+    inventory: InventoryItem[];
+    /** brain vault present + its layout version (from .brain-meta.json). */
+    hasBrain: boolean;
+    brainLayoutVersion?: number;
+    /** the reconciled state classification. */
+    state: NodeState;
+    /** actionable notes for the wizard / caller. */
+    notes: string[];
+}
+/** One recorded mutation, enabling undo. */
+export interface JournalOp {
+    kind: ActionKind;
+    path: string;
+    /** backup location (repo-relative) if the prior file was saved. */
+    backup?: string;
+    /** true if this op CREATED the file (undo = delete). */
+    created?: boolean;
+}
+export interface Journal {
+    engineVersion: string;
+    layoutVersion: number;
+    /** stamped by the caller (the engine forbids Date.now for determinism in
+     *  tests; the CLI passes a timestamp). */
+    at: string;
+    repo: string;
+    identity: ClanIdentity;
+    ops: JournalOp[];
+}
+export interface ApplyResult {
+    applied: PlanAction[];
+    journalPath?: string;
+    backupDir?: string;
+}
+export interface DoctorCheck {
+    name: string;
+    ok: boolean;
+    detail: string;
+}

package/dist/types.js

@@ -0,0 +1,12 @@
+/**
+ * Shared contract for the clan-engine. Every module imports from here; nothing
+ * else is cross-imported, so the pieces stay independently testable.
+ */
+/** Engine + layout versions. LAYOUT_VERSION is stamped into every generated
+ *  file's marker so a future engine can tell "my old output" from "my current
+ *  output" and run migrations. Bump LAYOUT_VERSION when the template SHAPE
+ *  changes (a path moves, a format changes); bump ENGINE_VERSION freely. */
+export const ENGINE_VERSION = '0.1.0';
+export const LAYOUT_VERSION = 1;
+/** The marker key written into generated-file frontmatter / headers. */
+export const GENERATED_BY = 'clan-engine';

package/dist/undo.d.ts

@@ -0,0 +1,14 @@
+/**
+ * undo — reverse an apply() run from its journal. Restores every backed-up file
+ * to its prior bytes and deletes every file the run created. The inverse of
+ * apply, so "try the clan and cleanly walk away" actually works.
+ */
+export interface UndoResult {
+    restored: string[];
+    removed: string[];
+    journal: string;
+}
+/** Undo the run described by a journal file (repo-relative or absolute path). */
+export declare function undo(repo: string, journalPath: string): UndoResult;
+/** List journals present in a repo (newest name last — they are timestamp-named). */
+export declare function listJournals(repo: string): string[];

package/dist/undo.js

@@ -0,0 +1,43 @@
+/**
+ * undo — reverse an apply() run from its journal. Restores every backed-up file
+ * to its prior bytes and deletes every file the run created. The inverse of
+ * apply, so "try the clan and cleanly walk away" actually works.
+ */
+import { readFileSync, existsSync, rmSync, mkdirSync, cpSync, readdirSync } from 'fs';
+import { join, dirname, isAbsolute } from 'path';
+/** Undo the run described by a journal file (repo-relative or absolute path). */
+export function undo(repo, journalPath) {
+    const jAbs = isAbsolute(journalPath) ? journalPath : join(repo, journalPath);
+    const journal = JSON.parse(readFileSync(jAbs, 'utf-8'));
+    const restored = [];
+    const removed = [];
+    // Reverse order so appends/creates unwind cleanly.
+    for (const op of [...journal.ops].reverse()) {
+        const abs = join(repo, op.path);
+        if (op.backup) {
+            const bkpAbs = join(repo, op.backup);
+            if (existsSync(bkpAbs)) {
+                mkdirSync(dirname(abs), { recursive: true });
+                rmSync(abs, { recursive: true, force: true });
+                cpSync(bkpAbs, abs, { recursive: true });
+                restored.push(op.path);
+            }
+        }
+        else if (op.created) {
+            rmSync(abs, { recursive: true, force: true });
+            removed.push(op.path);
+        }
+    }
+    return { restored, removed, journal: journalPath };
+}
+/** List journals present in a repo (newest name last — they are timestamp-named). */
+export function listJournals(repo) {
+    const dir = join(repo, '.claude', '.clan-engine');
+    try {
+        return readdirSync(dir).filter(f => f.startsWith('journal-') && f.endsWith('.json')).sort()
+            .map(f => join('.claude', '.clan-engine', f));
+    }
+    catch {
+        return [];
+    }
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@nfinitmonkeys/clan-engine",
+  "version": "0.1.0",
+  "description": "Deterministic setup engine for Nfinit Monkeys clans — the single template + reconciliation authority behind the published CLIs and the internal fleet tooling. Idempotent, dry-run-by-default, non-destructive.",
+  "type": "module",
+  "bin": {
+    "clan-engine": "./dist/cli.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "npm run build && node test/engine.test.mjs",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "nfinitmonkeys",
+    "clan",
+    "jungle",
+    "claude-code",
+    "mcp"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^22.20.1",
+    "typescript": "^5.6.3"
+  },
+  "dependencies": {
+    "yaml": "^2.9.0"
+  }
+}