@beomjk/emdd 0.1.0

package/dist/mcp-server/prompts/episode-creation.js

@@ -0,0 +1,75 @@
+export function registerEpisodeCreation(server) {
+    server.prompt('episode-creation', 'Step-by-step guide for writing an EMDD Episode node — includes frontmatter template, mandatory sections, and linking instructions', async () => {
+        const text = `# EMDD Episode Creation Guide
+
+An Episode is a session log that records what you tried, what you learned, and where to go next. It is the backbone of the EMDD temporal chain — each Episode curates the context for the next session.
+
+## Step-by-Step Checklist
+
+1. **Determine the Episode ID**: Use the next sequential ID (e.g., epi-004 if epi-003 exists).
+2. **Write the frontmatter** (see template below).
+3. **Fill in mandatory sections**:
+   - "What I Tried" — summarize the work done this session.
+   - "What's Next" — list planned next steps with prerequisite reading nodes.
+4. **Fill in optional sections** (include when relevant):
+   - "What Got Stuck" — blockers, wrong turns, or dead ends.
+   - "What Was Deliberately Not Done" — choices to defer or skip, with reasons.
+   - "Questions That Arose" — new questions to convert to Question nodes at consolidation.
+5. **Add links** to all nodes created, updated, or referenced during the session.
+6. **Verify prerequisite reading** under each "What's Next" item — this is critical for future context loading.
+
+## Frontmatter Template
+
+\`\`\`yaml
+---
+id: epi-XXX
+type: episode
+status: COMPLETED
+trigger: "Description of what prompted this session"
+created: YYYY-MM-DD
+updated: YYYY-MM-DD
+duration: ~Xm
+outcome: success | partial | blocked
+created_by: human:yourname
+tags: [relevant, tags]
+links:
+  - target: node-id
+    relation: produces
+---
+\`\`\`
+
+## Linking Instructions
+
+- Use \`produces\` for nodes created during this session.
+- Use \`relates_to\` for nodes referenced or updated.
+- Use \`context_for\` for nodes that provided background context.
+- Every Episode should link to at least one other node.
+
+## Body Template
+
+\`\`\`markdown
+# EPI-XXX: Session Title
+
+## What I Tried
+- [Summary of work done]
+
+## What Got Stuck
+- [Blockers or wrong turns — omit if nothing got stuck]
+
+## What's Next
+- [ ] Next step description
+  - Prerequisite reading: node-id-1, node-id-2
+- [ ] Another next step
+  - Prerequisite reading: node-id-3
+\`\`\`
+
+## Principles
+- Keep Episodes short — "What I Tried" and "What's Next" are the only mandatory sections.
+- A five-line Episode is better than no Episode.
+- Do not record Consolidation as an Episode — Consolidation is a meta-activity.
+- Write the Episode at the end of each session, not days later.`;
+        return {
+            messages: [{ role: 'user', content: { type: 'text', text } }],
+        };
+    });
+}

package/dist/mcp-server/prompts/health-review.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerHealthReview(server: McpServer): void;

package/dist/mcp-server/prompts/health-review.js

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+import { getHealth } from '../../graph/operations.js';
+export function registerHealthReview(server) {
+    server.prompt('health-review', 'Full health dashboard with actionable recommendations — analyzes node distribution, structural gaps, and link density', { path: z.string().describe('Path to the EMDD graph directory') }, async ({ path: graphDir }) => {
+        const health = await getHealth(graphDir);
+        const typeBreakdown = Object.entries(health.byType)
+            .map(([type, count]) => `  - ${type}: ${count}`)
+            .join('\n');
+        const statusSection = Object.entries(health.statusDistribution)
+            .map(([type, statuses]) => {
+            const statusList = Object.entries(statuses)
+                .map(([s, c]) => `${s}: ${c}`)
+                .join(', ');
+            return `  - ${type}: ${statusList}`;
+        })
+            .join('\n');
+        const gapsSection = health.gaps.length > 0
+            ? health.gaps.map(g => `  - ${g}`).join('\n')
+            : '  None detected';
+        // Generate recommendations based on health data
+        const recommendations = [];
+        if (health.gaps.length > 0) {
+            for (const gap of health.gaps) {
+                recommendations.push(`[ACTION] Address structural gap: ${gap}`);
+            }
+        }
+        if (health.linkDensity < 1.0 && health.totalNodes > 0) {
+            recommendations.push(`[ACTION] Low link density (${health.linkDensity.toFixed(2)}). Many nodes lack connections. Run orphan cleanup to add missing edges.`);
+        }
+        if (health.openQuestions === 0 && health.totalNodes > 0) {
+            recommendations.push('[ACTION] No open questions. This may indicate premature convergence. Consider generating new questions during consolidation.');
+        }
+        if (health.avgConfidence !== null && health.avgConfidence < 0.5) {
+            recommendations.push(`[ACTION] Low average confidence (${health.avgConfidence.toFixed(2)}). Prioritize experiments that test high-risk hypotheses.`);
+        }
+        if ((health.byType['finding'] ?? 0) >= 5 && (health.byType['knowledge'] ?? 0) === 0) {
+            recommendations.push('[ACTION] Multiple findings but no knowledge nodes. Run a consolidation to promote validated findings.');
+        }
+        if ((health.byType['episode'] ?? 0) === 0 && health.totalNodes > 0) {
+            recommendations.push('[ACTION] No episode nodes. Write an episode to record your session and maintain the temporal chain.');
+        }
+        if (recommendations.length === 0) {
+            recommendations.push('Graph health looks good. Continue with the current research loop.');
+        }
+        const recommendationsSection = recommendations.map(r => `  - ${r}`).join('\n');
+        const text = `# EMDD Health Review
+
+## Summary
+- Total nodes: ${health.totalNodes}
+- Total edges: ${health.totalEdges}
+- Link density: ${health.linkDensity.toFixed(2)} edges/node
+- Average confidence: ${health.avgConfidence !== null ? health.avgConfidence.toFixed(2) : 'N/A'}
+- Open questions: ${health.openQuestions}
+
+## Node Distribution by Type
+${typeBreakdown}
+
+## Status Distribution
+${statusSection}
+
+## Structural Gaps
+${gapsSection}
+
+## Recommendations
+${recommendationsSection}
+
+## Next Steps
+1. Address any [ACTION] items in the recommendations above.
+2. If consolidation triggers are active, run the \`consolidation\` prompt for a guided procedure.
+3. Use the \`check\` tool to verify consolidation trigger status.
+4. Schedule a Weekly Graph Review if one has not been done in the past 7 days.`;
+        return {
+            messages: [{ role: 'user', content: { type: 'text', text } }],
+        };
+    });
+}

package/dist/mcp-server/tools/check.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerCheck(server: McpServer): void;

package/dist/mcp-server/tools/check.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { checkConsolidation } from '../../graph/operations.js';
+import { jsonResult } from './util.js';
+export function registerCheck(server) {
+    server.tool('check', 'Check consolidation triggers in the EMDD graph', {
+        graphDir: z.string().describe('Path to the EMDD graph directory'),
+    }, async ({ graphDir }) => {
+        const result = await checkConsolidation(graphDir);
+        return jsonResult(result);
+    });
+}

package/dist/mcp-server/tools/create-edge.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerCreateEdge(server: McpServer): void;

package/dist/mcp-server/tools/create-edge.js

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { createEdge } from '../../graph/operations.js';
+import { jsonResult, withErrorHandling } from './util.js';
+export function registerCreateEdge(server) {
+    server.tool('create-edge', 'Add an edge (link) from source to target with the given relation', {
+        graphDir: z.string().describe('Path to the EMDD graph directory'),
+        source: z.string().describe('Source node ID'),
+        target: z.string().describe('Target node ID'),
+        relation: z.string().describe('Relation type (supports, contradicts, spawns, etc.)'),
+    }, async ({ graphDir, source, target, relation }) => withErrorHandling(async () => {
+        const result = await createEdge(graphDir, source, target, relation);
+        return jsonResult(result);
+    }));
+}

package/dist/mcp-server/tools/create-node.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerCreateNode(server: McpServer): void;

package/dist/mcp-server/tools/create-node.js

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { createNode } from '../../graph/operations.js';
+import { jsonResult, withErrorHandling } from './util.js';
+export function registerCreateNode(server) {
+    server.tool('create-node', 'Create a new node of the given type with the given slug', {
+        graphDir: z.string().describe('Path to the EMDD graph directory'),
+        type: z.string().describe('Node type (hypothesis, experiment, finding, knowledge, question, decision, episode)'),
+        slug: z.string().describe('URL-friendly slug for the node'),
+        lang: z.string().optional().describe('Language locale (default: en)'),
+    }, async ({ graphDir, type, slug, lang }) => withErrorHandling(async () => {
+        const result = await createNode(graphDir, type, slug, lang);
+        return jsonResult(result);
+    }));
+}

package/dist/mcp-server/tools/health.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerHealth(server: McpServer): void;

package/dist/mcp-server/tools/health.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { getHealth } from '../../graph/operations.js';
+import { jsonResult } from './util.js';
+export function registerHealth(server) {
+    server.tool('health', 'Compute a health report for the EMDD graph', {
+        graphDir: z.string().describe('Path to the EMDD graph directory'),
+    }, async ({ graphDir }) => {
+        const report = await getHealth(graphDir);
+        return jsonResult(report);
+    });
+}

package/dist/mcp-server/tools/list-nodes.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerListNodes(server: McpServer): void;

package/dist/mcp-server/tools/list-nodes.js

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { listNodes } from '../../graph/operations.js';
+import { jsonResult } from './util.js';
+export function registerListNodes(server) {
+    server.tool('list-nodes', 'List all nodes in the EMDD graph, optionally filtered by type and/or status', {
+        graphDir: z.string().describe('Path to the EMDD graph directory'),
+        type: z.string().optional().describe('Filter by node type (hypothesis, experiment, finding, etc.)'),
+        status: z.string().optional().describe('Filter by status'),
+    }, async ({ graphDir, type, status }) => {
+        const filter = {};
+        if (type)
+            filter.type = type;
+        if (status)
+            filter.status = status;
+        const nodes = await listNodes(graphDir, filter);
+        return jsonResult(nodes);
+    });
+}

package/dist/mcp-server/tools/promote.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerPromote(server: McpServer): void;

package/dist/mcp-server/tools/promote.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { getPromotionCandidates } from '../../graph/operations.js';
+import { jsonResult } from './util.js';
+export function registerPromote(server) {
+    server.tool('promote', 'Identify findings eligible for promotion to knowledge', {
+        graphDir: z.string().describe('Path to the EMDD graph directory'),
+    }, async ({ graphDir }) => {
+        const candidates = await getPromotionCandidates(graphDir);
+        return jsonResult(candidates);
+    });
+}

package/dist/mcp-server/tools/read-node.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerReadNode(server: McpServer): void;

package/dist/mcp-server/tools/read-node.js

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { readNode } from '../../graph/operations.js';
+import { jsonResult, errorResult } from './util.js';
+export function registerReadNode(server) {
+    server.tool('read-node', 'Read a single node by ID, returning full detail including body text', {
+        graphDir: z.string().describe('Path to the EMDD graph directory'),
+        nodeId: z.string().describe('Node ID (e.g., hyp-001)'),
+    }, async ({ graphDir, nodeId }) => {
+        const detail = await readNode(graphDir, nodeId);
+        if (!detail) {
+            return errorResult(`Node not found: ${nodeId}`);
+        }
+        return jsonResult(detail);
+    });
+}

package/dist/mcp-server/tools/util.d.ts

@@ -0,0 +1,7 @@
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+/** Wrap a result value as MCP text content */
+export declare function jsonResult(data: unknown): CallToolResult;
+/** Wrap an error message as MCP error content */
+export declare function errorResult(message: string): CallToolResult;
+/** Execute an async operation, catching errors and returning MCP error content */
+export declare function withErrorHandling(fn: () => Promise<CallToolResult>): Promise<CallToolResult>;

package/dist/mcp-server/tools/util.js

@@ -0,0 +1,22 @@
+/** Wrap a result value as MCP text content */
+export function jsonResult(data) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+    };
+}
+/** Wrap an error message as MCP error content */
+export function errorResult(message) {
+    return {
+        isError: true,
+        content: [{ type: 'text', text: message }],
+    };
+}
+/** Execute an async operation, catching errors and returning MCP error content */
+export async function withErrorHandling(fn) {
+    try {
+        return await fn();
+    }
+    catch (err) {
+        return errorResult(err.message);
+    }
+}

package/dist/rules/emdd-agent.md

@@ -0,0 +1,40 @@
+# EMDD Agent Behavior Guidelines
+
+## Session Workflow
+
+1. **Session Start**: Read the latest Episode's "What's Next" section. Load prerequisite nodes.
+2. **During Work**: Execute experiments, write code, take notes. Mark surprises with [!].
+3. **Session End**: Write a new Episode. Record what was tried, create Findings, list next steps.
+
+## Intervention Rules
+
+- During deep work: do not interrupt unless a kill criterion is hit or a crash occurs
+- Suggestions are a menu, not an order — the researcher selects what to pursue
+- After a suggestion is rejected: 24-hour cooldown before re-suggesting
+- Never negate an idea still forming in early exploration stages
+
+## Authority Scope
+
+**No approval needed:**
+- Recording experiment metrics as Finding/Result nodes
+- Updating Experiment status (PLANNED -> RUNNING -> COMPLETED)
+- Time-based attribute updates (updated field)
+
+**Approval required:**
+- Changing Hypothesis confidence
+- Creating new Hypothesis or Question nodes
+- Adding or deleting edges
+- Changing Knowledge status (DISPUTED/RETRACTED)
+
+**Forbidden:**
+- Deleting any node (archive/deprecate instead)
+- Creating Decision nodes
+- Modifying kill criteria
+
+## Graph Maintenance Tasks
+
+- After experiments: update related node statuses and confidence scores (with approval)
+- Check Consolidation triggers after creating Episodes or Findings
+- Identify orphan nodes (nodes with no outgoing links)
+- Detect stale nodes (untested hypotheses older than 3 days)
+- Flag structural gaps between clusters

package/dist/rules/emdd-rules.md

@@ -0,0 +1,99 @@
+# EMDD — Evolving Mindmap-Driven Development
+
+You are working in a project that uses the EMDD methodology. EMDD organizes research and exploration as a knowledge graph stored in `graph/` with Markdown + YAML frontmatter files, tracked by Git.
+
+## Graph Structure
+
+The graph contains 7 node types, each in its own subdirectory:
+
+| Node Type | Directory | Purpose |
+|-----------|-----------|---------|
+| Hypothesis | `graph/hypotheses/` | Testable claims with confidence scores |
+| Experiment | `graph/experiments/` | Units of work that test hypotheses |
+| Finding | `graph/findings/` | Observations from experiments |
+| Knowledge | `graph/knowledge/` | Established facts promoted from findings |
+| Question | `graph/questions/` | Open questions driving exploration |
+| Decision | `graph/decisions/` | Recorded choices with rationale |
+| Episode | `graph/episodes/` | Session logs linking work to the graph |
+
+Nodes are connected by typed edges (supports, contradicts, spawns, produces, tests, depends_on, extends, promotes, answers, etc.) declared in YAML frontmatter `links:` arrays.
+
+## Node File Format
+
+Every node is a Markdown file with YAML frontmatter:
+
+```yaml
+---
+id: hyp-001
+type: hypothesis
+status: PROPOSED
+confidence: 0.4
+created: 2026-03-15
+updated: 2026-03-15
+created_by: human:yourname
+tags: [topic]
+links:
+  - target: know-001
+    relation: depends_on
+---
+# Title here
+Body content...
+```
+
+Required fields vary by type. All nodes need: `id`, `type`, `status`, `created`, `updated`. Hypotheses and findings also need `confidence` (0.0-1.0).
+
+## Node ID Convention
+
+IDs use type prefix + sequential number: `hyp-001`, `exp-003`, `fnd-012`, `knw-005`, `qst-002`, `dec-001`, `epi-007`.
+
+## Episode Writing Protocol
+
+Episodes are the primary mechanism for maintaining research continuity. Write an Episode at the end of each work session.
+
+**Mandatory sections:**
+- **What I Tried** — what was done this session
+- **What's Next** — planned next steps with prerequisite reading nodes
+
+**Optional sections:**
+- What Got Stuck — blockers or wrong turns
+- What Was Deliberately Not Done — deferred items with reasons
+- Questions That Arose — new questions for the graph
+
+Each "What's Next" item should list prerequisite reading: the node IDs to load before starting that task. This curates context for the next session.
+
+## Consolidation Protocol
+
+Consolidation is a mandatory maintenance ceremony. Check triggers after creating Episodes or Findings.
+
+**Triggers (run if ANY apply):**
+- 5 or more Finding nodes added since last Consolidation
+- 3 or more Episode nodes added since last Consolidation
+- 0 open Questions (the illusion that research is "done")
+- An Experiment has 5+ Findings attached
+
+**Consolidation steps:**
+1. **Promotion** — promote established Findings to Knowledge nodes
+2. **Splitting** — split bloated Experiments into meaningful units
+3. **Question generation** — convert Episode questions into Question nodes
+4. **Hypothesis update** — update confidence based on evidence
+5. **Orphan cleanup** — add connections to unlinked Findings
+
+Consolidation is an obligation, not optional. Do not record Consolidation as an Episode. Do not start new exploration during Consolidation.
+
+## Key Principles
+
+1. **Graph is source of truth** — the graph, not code, is the project's knowledge structure
+2. **Minimum viable structure** — add structure only when needed; if it feels like bureaucracy, reduce it
+3. **Gap-driven exploration** — the most valuable information is in the empty spaces between nodes
+4. **Temporal evolution** — never delete wrong paths; deprecate them. The history of why something failed is itself knowledge
+5. **Riskiest-first** — validate the most uncertain hypotheses first
+6. **Archive, don't delete** — change status to REFUTED/RETRACTED/SUPERSEDED instead of removing nodes
+
+## AI Agent Role
+
+You are a **gardener** of the graph:
+- Maintain connections, detect duplicates, identify orphans
+- Detect patterns and potential connections the researcher missed
+- Suggest exploration directions based on structural gaps
+- Automate routine tasks (literature search, result summarization)
+- Never make judgment calls — suggest, don't decide

package/dist/rules/generators.d.ts

@@ -0,0 +1,18 @@
+export type ToolType = 'claude' | 'cursor' | 'windsurf' | 'cline' | 'copilot' | 'all';
+export type RulesVariant = 'full' | 'compact';
+/**
+ * Get rules content for a specific tool and variant.
+ * For 'all', returns claude content (use generateRulesFile for writing all files).
+ */
+export declare function getRulesContent(tool: ToolType, variant: RulesVariant): string;
+/**
+ * Generate rules file(s) for the given tool at the project path.
+ * Returns an object with created file paths and any warnings.
+ */
+export declare function generateRulesFile(tool: ToolType, projectPath: string, options?: {
+    variant?: RulesVariant;
+    force?: boolean;
+}): {
+    created: string[];
+    skipped: string[];
+};

package/dist/rules/generators.js

@@ -0,0 +1,104 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// Tool -> output path mapping (relative to project root)
+const TOOL_PATHS = {
+    claude: '.claude/CLAUDE.md',
+    cursor: '.cursor/rules/emdd.mdc',
+    windsurf: '.windsurf/rules/emdd.md',
+    cline: '.clinerules/emdd.md',
+    copilot: '.github/copilot-instructions.md',
+};
+const ALL_TOOLS = ['claude', 'cursor', 'windsurf', 'cline', 'copilot'];
+function loadRulesMarkdown() {
+    return fs.readFileSync(path.join(__dirname, 'emdd-rules.md'), 'utf-8');
+}
+function loadAgentMarkdown() {
+    return fs.readFileSync(path.join(__dirname, 'emdd-agent.md'), 'utf-8');
+}
+function makeCompactRules() {
+    // Compact version: essential rules only, targeting ~1500 tokens (~6000 chars)
+    return `# EMDD — Evolving Mindmap-Driven Development (Compact)
+
+You are working in an EMDD project. The knowledge graph lives in \`graph/\` as Markdown + YAML frontmatter files.
+
+## Node Types
+
+- **Hypothesis** (\`graph/hypotheses/\`) — testable claims with confidence 0.0-1.0
+- **Experiment** (\`graph/experiments/\`) — work units testing hypotheses
+- **Finding** (\`graph/findings/\`) — observations from experiments
+- **Knowledge** (\`graph/knowledge/\`) — established facts promoted from findings
+- **Question** (\`graph/questions/\`) — open questions driving exploration
+- **Decision** (\`graph/decisions/\`) — recorded choices with rationale
+- **Episode** (\`graph/episodes/\`) — session logs (mandatory: "What I Tried" + "What's Next")
+
+## ID Convention
+
+\`hyp-001\`, \`exp-003\`, \`fnd-012\`, \`knw-005\`, \`qst-002\`, \`dec-001\`, \`epi-007\`
+
+## Key Rules
+
+1. Write an Episode at end of each session with "What I Tried" and "What's Next" (with prerequisite node IDs)
+2. Run Consolidation when: 5+ Findings, 3+ Episodes, 0 open Questions, or 5+ Findings on one Experiment
+3. Consolidation steps: Promote findings, split experiments, generate questions, update confidence, fix orphans
+4. Never delete nodes — change status to REFUTED/RETRACTED/SUPERSEDED
+5. Graph is source of truth; you are a gardener, not an architect — suggest, don't decide
+`;
+}
+function wrapForCursor(content) {
+    return `---
+description: EMDD methodology rules for AI-assisted research graph management
+globs: graph/**/*.md
+---
+${content}`;
+}
+/**
+ * Get rules content for a specific tool and variant.
+ * For 'all', returns claude content (use generateRulesFile for writing all files).
+ */
+export function getRulesContent(tool, variant) {
+    const resolvedTool = tool === 'all' ? 'claude' : tool;
+    let content;
+    if (variant === 'compact') {
+        content = makeCompactRules();
+    }
+    else {
+        const rules = loadRulesMarkdown();
+        const agent = loadAgentMarkdown();
+        content = `${rules}\n\n${agent}`;
+    }
+    // Apply tool-specific formatting
+    if (resolvedTool === 'cursor') {
+        return wrapForCursor(content);
+    }
+    return content;
+}
+/**
+ * Generate rules file(s) for the given tool at the project path.
+ * Returns an object with created file paths and any warnings.
+ */
+export function generateRulesFile(tool, projectPath, options = {}) {
+    const variant = options.variant ?? 'full';
+    const force = options.force ?? false;
+    const tools = tool === 'all' ? ALL_TOOLS : [tool];
+    const created = [];
+    const skipped = [];
+    for (const t of tools) {
+        const relativePath = TOOL_PATHS[t];
+        const fullPath = path.join(projectPath, relativePath);
+        const dir = path.dirname(fullPath);
+        // Check if file already exists
+        if (!force && fs.existsSync(fullPath)) {
+            skipped.push(relativePath);
+            continue;
+        }
+        // Create directory if needed
+        fs.mkdirSync(dir, { recursive: true });
+        // Write the content
+        const content = getRulesContent(t, variant);
+        fs.writeFileSync(fullPath, content, 'utf-8');
+        created.push(relativePath);
+    }
+    return { created, skipped };
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@beomjk/emdd",
+  "version": "0.1.0",
+  "description": "CLI for Evolving Mindmap-Driven Development",
+  "type": "module",
+  "bin": {
+    "emdd": "dist/cli.js",
+    "emdd-mcp": "dist/mcp-server/cli.js"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "main": "./dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/cli.ts",
+    "test": "vitest",
+    "test:run": "vitest run --passWithNoTests",
+    "lint": "tsc --noEmit",
+    "demo:record": "terminal-demo play docs/assets/demo.md --record docs/assets/demo.cast && svg-term --in docs/assets/demo.cast --out docs/assets/demo.svg --window --width 80 --height 24"
+  },
+  "keywords": [
+    "emdd",
+    "mindmap",
+    "research",
+    "knowledge-graph",
+    "cli"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "chalk": "^5.6.2",
+    "cli-table3": "^0.6.5",
+    "commander": "^14.0.3",
+    "glob": "^13.0.6",
+    "gray-matter": "^4.0.3",
+    "js-yaml": "^4.1.1",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "react": "^16.14.0",
+    "svg-term-cli": "^2.1.1",
+    "terminal-demo": "^0.1.11",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.0"
+  }
+}