pi-shepherd 0.1.0

package/README.en.md

@@ -0,0 +1,136 @@
+[中文文档](README.md) | English
+
+# pi-shepherd
+
+Line count guard and behavior rules extension for [pi-coding-agent](https://github.com/earendil-works/pi-coding-agent) — rule-driven hooks for tool calls, agent end, and session events.
+
+## What It Does
+
+AI agents can go off the rails — generate too much code, forget to commit, ignore coding standards, or produce outputs that are too large. pi-shepherd acts as a **guardrail system** that monitors and enforces behavioral rules:
+
+- **Tool call interception** — Inspect and modify tool calls before execution (e.g., enforce line limits)
+- **Tool result inspection** — Check tool results after execution (e.g., flag overly large outputs)
+- **Agent end hooks** — Enforce commit/message rules when the agent finishes
+- **Session lifecycle** — Reset state between sessions
+
+## Installation
+
+```bash
+pi install git:github.com/catlain/pi-shepherd
+```
+
+## How It Works
+
+pi-shepherd uses a **rules engine** that evaluates configurable patterns against tool calls and results:
+
+```
+Tool Call → Rules Engine → Pass/Block/Modify
+Tool Result → Rules Engine → Pass/Flag/Truncate
+Agent End → Rules Engine → Enforce (commit, summarize, etc.)
+```
+
+### Rules Format
+
+Rules are defined in `rules.json` (or the `shepherd` section of settings):
+
+```json
+[
+  {
+    "name": "block-grep-for-code-graph",
+    "pattern": "^grep\\s+.*\\b[A-Z][a-zA-Z]+\\(",
+    "type": "tool_call",
+    "action": "block",
+    "message": "Use code-graph search_symbols instead of grep for symbol names"
+  },
+  {
+    "name": "warn-large-edit",
+    "pattern": "edit",
+    "type": "tool_result",
+    "maxLines": 500,
+    "action": "warn",
+    "message": "Edit result is large, consider breaking into smaller changes"
+  }
+]
+```
+
+### Rule Types
+
+| Type | When Evaluated | Actions |
+|------|---------------|---------|
+| `tool_call` | Before tool execution | `pass`, `block`, `modify` |
+| `tool_result` | After tool execution | `pass`, `warn`, `truncate` |
+| `agent_end` | When agent finishes | `enforce` |
+
+## Built-in Rules
+
+pi-shepherd ships with default rules for common anti-patterns:
+
+- Redirect `grep` to `code-graph` for symbol searches
+- Warn on overly large tool results
+- Enforce git commit on agent end
+- Block redundant file reads
+
+## Configuration
+
+```json
+{
+  "shepherd": {
+    "enabled": true,
+    "rulesDir": "~/.pi/agent/shepherd-rules"
+  }
+}
+```
+
+## Use Cases
+
+| Scenario | Rule Type | Action |
+|----------|-----------|--------|
+| **Enforce coding standards** | `tool_call` | Block tools that don't follow conventions |
+| **Prevent context bloat** | `tool_result` | Truncate large results |
+| **Git discipline** | `agent_end` | Force commit at session end |
+| **Redirect to better tools** | `tool_call` | Block grep, suggest code-graph |
+| **Custom team rules** | All types | Project-specific guardrails |
+
+## Best Practices
+
+### ✅ Recommended
+- Start with built-in rules, then add project-specific ones
+- Use `warn` before `block` — give the agent a chance to learn
+- Keep rule patterns simple and specific — regex is evaluated on every tool call
+- Put project rules in `.pi/shepherd-rules/` for version control
+
+### ❌ Not Recommended
+- Don't use overly broad patterns — they'll match too many calls and slow things down
+- Don't create contradictory rules (block + allow the same pattern)
+- Don't rely on shepherd for security — it's a guide, not a sandbox
+
+## Limitations
+
+| Limitation | Detail |
+|------------|--------|
+| Regex only | Patterns use regex, not semantic understanding |
+| No async rules | Rules must evaluate synchronously |
+| Agent can bypass | Determined agents can ignore warnings |
+| No persistence | Rule state resets between sessions |
+
+## Architecture
+
+```
+pi-shepherd/
+├── index.ts          # Entry: register hooks + rules engine
+├── rules-engine.ts   # Pattern matching + action dispatch
+├── rules/            # Built-in rule definitions
+│   ├── grep.ts       # Redirect grep → code-graph
+│   ├── line-limit.ts # Warn on large outputs
+│   └── agent-end.ts  # Enforce git commit
+├── types.ts          # Rule type definitions
+└── package.json
+```
+
+**Dependencies**:
+- `@pi-atelier/shared-utils` (bundled) — settings management
+- `@earendil-works/pi-coding-agent` — ExtensionAPI (peer)
+
+## License
+
+MIT

package/README.md

@@ -0,0 +1,136 @@
+[English](README.en.md) | 程序中文文档
+
+# pi-shepherd
+
+Line count guard and behavior rules extension for [pi-coding-agent](https://github.com/earendil-works/pi-coding-agent) — rule-driven hooks for tool calls, agent end, and session events.
+
+## What It Does
+
+AI agents can go off the rails — generate too much code, forget to commit, ignore coding standards, or produce outputs that are too large. pi-shepherd acts as a **guardrail system** that monitors and enforces behavioral rules:
+
+- **Tool call interception** — Inspect and modify tool calls before execution (e.g., enforce line limits)
+- **Tool result inspection** — Check tool results after execution (e.g., flag overly large outputs)
+- **Agent end hooks** — Enforce commit/message rules when the agent finishes
+- **Session lifecycle** — Reset state between sessions
+
+## Installation
+
+```bash
+pi install git:github.com/catlain/pi-shepherd
+```
+
+## How It Works
+
+pi-shepherd uses a **rules engine** that evaluates configurable patterns against tool calls and results:
+
+```
+Tool Call → Rules Engine → Pass/Block/Modify
+Tool Result → Rules Engine → Pass/Flag/Truncate
+Agent End → Rules Engine → Enforce (commit, summarize, etc.)
+```
+
+### Rules Format
+
+Rules are defined in `rules.json` (or the `shepherd` section of settings):
+
+```json
+[
+  {
+    "name": "block-grep-for-code-graph",
+    "pattern": "^grep\\s+.*\\b[A-Z][a-zA-Z]+\\(",
+    "type": "tool_call",
+    "action": "block",
+    "message": "Use code-graph search_symbols instead of grep for symbol names"
+  },
+  {
+    "name": "warn-large-edit",
+    "pattern": "edit",
+    "type": "tool_result",
+    "maxLines": 500,
+    "action": "warn",
+    "message": "Edit result is large, consider breaking into smaller changes"
+  }
+]
+```
+
+### Rule Types
+
+| Type | When Evaluated | Actions |
+|------|---------------|---------|
+| `tool_call` | Before tool execution | `pass`, `block`, `modify` |
+| `tool_result` | After tool execution | `pass`, `warn`, `truncate` |
+| `agent_end` | When agent finishes | `enforce` |
+
+## Built-in Rules
+
+pi-shepherd ships with default rules for common anti-patterns:
+
+- Redirect `grep` to `code-graph` for symbol searches
+- Warn on overly large tool results
+- Enforce git commit on agent end
+- Block redundant file reads
+
+## Configuration
+
+```json
+{
+  "shepherd": {
+    "enabled": true,
+    "rulesDir": "~/.pi/agent/shepherd-rules"
+  }
+}
+```
+
+## Use Cases
+
+| Scenario | Rule Type | Action |
+|----------|-----------|--------|
+| **Enforce coding standards** | `tool_call` | Block tools that don't follow conventions |
+| **Prevent context bloat** | `tool_result` | Truncate large results |
+| **Git discipline** | `agent_end` | Force commit at session end |
+| **Redirect to better tools** | `tool_call` | Block grep, suggest code-graph |
+| **Custom team rules** | All types | Project-specific guardrails |
+
+## Best Practices
+
+### ✅ Recommended
+- Start with built-in rules, then add project-specific ones
+- Use `warn` before `block` — give the agent a chance to learn
+- Keep rule patterns simple and specific — regex is evaluated on every tool call
+- Put project rules in `.pi/shepherd-rules/` for version control
+
+### ❌ Not Recommended
+- Don't use overly broad patterns — they'll match too many calls and slow things down
+- Don't create contradictory rules (block + allow the same pattern)
+- Don't rely on shepherd for security — it's a guide, not a sandbox
+
+## Limitations
+
+| Limitation | Detail |
+|------------|--------|
+| Regex only | Patterns use regex, not semantic understanding |
+| No async rules | Rules must evaluate synchronously |
+| Agent can bypass | Determined agents can ignore warnings |
+| No persistence | Rule state resets between sessions |
+
+## Architecture
+
+```
+pi-shepherd/
+├── index.ts          # Entry: register hooks + rules engine
+├── rules-engine.ts   # Pattern matching + action dispatch
+├── rules/            # Built-in rule definitions
+│   ├── grep.ts       # Redirect grep → code-graph
+│   ├── line-limit.ts # Warn on large outputs
+│   └── agent-end.ts  # Enforce git commit
+├── types.ts          # Rule type definitions
+└── package.json
+```
+
+**Dependencies**:
+- `@pi-atelier/shared-utils` (bundled) — settings management
+- `@earendil-works/pi-coding-agent` — ExtensionAPI (peer)
+
+## License
+
+MIT

package/index.ts

@@ -0,0 +1,229 @@
+/**
+ * Shepherd — 通用 Hook 规则引擎
+ *
+ * 规则驱动的事件 hook，支持多种动作：
+ *   - tool_call:  工具调用前（可 block 拦截 / notify 提醒 / rewrite 重写）
+ *   - tool_result: 工具执行后（可 notify 提醒 / steer 向 LLM 注入 + 行数检查）
+ *   - agent_end: AI 正常完成时（可 notify 提醒，支持 stopReason 过滤）
+ *   - session_shutdown: 会话结束时（可 notify 提醒）
+ *
+ * steer/notify 提示通过 before_provider_request 临时注入到 LLM payload，
+ * 不写入 session 历史，不占用后续上下文。
+ *
+ * 规则配置文件:
+ *   全局: ~/.pi/agent/extensions/shepherd/rules.json
+ *   项目级: <cwd>/.pi/extensions/shepherd-rules-*.json（自动扫描，叠加加载）
+ *
+ * 修改规则文件后 /reload 即可生效，无需重启 pi。
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+
+/** pi payload 消息结构的最小类型 */
+interface PayloadMessage {
+	role: string;
+	content?: unknown;
+	[key: string]: unknown;
+}
+
+/** pi provider payload 的最小类型 */
+interface ProviderPayload {
+	messages?: PayloadMessage[];
+	[key: string]: unknown;
+}
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const RULES_DIR = __dirname;
+
+import { getEffectiveConfig } from "@pi-atelier/shared-utils";
+import {
+	checkWorktrees,
+	drainHints,
+	hasGitUncommittedChanges,
+	hasWarnings,
+	isSubagent,
+	loadRules,
+	notifySummary,
+	pushWarning,
+	registerToolCall,
+	registerToolResult,
+	StateTracker,
+	type ToolState,
+} from "./shepherd";
+import { registerRulesEditorTool } from "./shepherd/rules-tool";
+
+/** 本地 hints 缓冲区（收集 pi.events.emit("ephemeral:hint") 的数据） */
+const _localHints: { text: string; short?: string }[] = [];
+
+/** 可变状态：跨 hook 共享 */
+let _aborted = false;
+let _wasDirty = false;
+const _agentEndFired = new Set<string>();
+const _toolState: ToolState = {
+	hasEdits: false,
+	tracker: new StateTracker(),
+	cachedTools: null,
+};
+
+export default function shepherdExtension(pi: ExtensionAPI) {
+	// ── 读取配置（三层合并：defaults → 全局 settings → 项目 settings）──
+	const shepherdConfig = getEffectiveConfig<{
+		projectRulesPattern: string;
+		maxWarnings: number;
+	}>(
+		"shepherd",
+		{
+			projectRulesPattern: "shepherd-rules-",
+			maxWarnings: 5,
+		},
+		process.cwd(),
+	);
+
+	// ── 监听跨扩展 hints（通过 pi.events 绕过 jiti 多实例） ──
+	pi.events.on("ephemeral:hint", (data) => {
+		const { text, short } = data as { text: string; short?: string };
+		_localHints.push({ text, short });
+	});
+
+	// ── before_provider_request：注入临时提示 ──────────────────
+	pi.on("before_provider_request", async (event, ctx) => {
+		// shepherd 规则 hints
+		const shepherdText = drainHints();
+		if (shepherdText) {
+			_localHints.unshift({ text: shepherdText });
+		}
+
+		// 通知摘要：short 优先，fallback 到 notifySummary 截断
+		const shortParts = _localHints
+			.map((h) => h.short)
+			.filter(Boolean) as string[];
+		const longParts = _localHints
+			.map((h) => (h.short ? null : h.text))
+			.filter(Boolean) as string[];
+		const notifyText = [...shortParts, ...longParts].join("\n\n");
+
+		const allHints = _localHints
+			.splice(0)
+			.map((h) => h.text)
+			.join("\n\n");
+		let payload = event.payload as ProviderPayload;
+
+		if (allHints) {
+			const text = allHints;
+			payload = { ...payload };
+			payload.messages = [...(payload.messages ?? [])];
+			payload.messages.push({
+				role: "user",
+				content: [{ type: "text", text }],
+			});
+			ctx.ui.notify?.(notifySummary(notifyText), "warning");
+		}
+
+		return payload;
+	});
+
+	// ── session_start ──────────────────────────────────────────
+	pi.on("session_start", async (_event, ctx) => {
+		checkWorktrees(ctx.ui);
+	});
+
+	// ── agent_start ────────────────────────────────────────────
+	pi.on("agent_start", async (_event, ctx) => {
+		_aborted = ctx.signal?.aborted ?? false;
+		_toolState.hasEdits = false;
+		_toolState.cachedTools = null;
+		_agentEndFired.clear();
+		if (ctx.signal && !ctx.signal.aborted) {
+			ctx.signal.addEventListener("abort", () => {
+				_aborted = true;
+			});
+		}
+		_wasDirty = hasGitUncommittedChanges();
+	});
+
+	pi.on("input", async (_event) => {
+		/* 占位：防止 shepherd steer 循环 */
+	});
+
+	// ── agent_end ──────────────────────────────────────────────
+	pi.on("agent_end", async (event, _ctx) => {
+		if (isSubagent() || _aborted) return;
+		const rules = loadRules(RULES_DIR, {
+			projectRulesPattern: shepherdConfig.projectRulesPattern,
+		}).filter((r) => r.hook === "agent_end");
+		if (rules.length === 0) return;
+
+		const lastAssistant = [...event.messages]
+			.reverse()
+			.find((m: PayloadMessage) => m.role === "assistant");
+		const stopReason: string | undefined = (lastAssistant as PayloadMessage | undefined)?.stopReason as string | undefined;
+
+		for (const rule of rules) {
+			const allowedReasons = rule.stopReason ?? ["stop"];
+			if (!allowedReasons.includes(stopReason ?? "")) continue;
+			if (_agentEndFired.has(rule.comment)) continue;
+
+			let shouldNotify = false;
+			if (rule.check === "git_uncommitted") {
+				const isDirty = hasGitUncommittedChanges();
+				shouldNotify = isDirty && _toolState.hasEdits;
+				_wasDirty = isDirty;
+			} else if (rule.check === "has_edits") {
+				// hasEdits：本轮是否调用过 edit/write，用于提醒记忆更新和总结
+				shouldNotify = _toolState.hasEdits;
+			} else if (rule.check === "always" || !rule.check) {
+				shouldNotify = true;
+			}
+
+			if (shouldNotify && rule.action === "notify") {
+				_agentEndFired.add(rule.comment);
+				pushWarning(rule.reason, rule.comment);
+			}
+		}
+
+		// 如有缓冲提示，用极简消息触发新 turn（before_provider_request 会注入实际内容）
+		if (hasWarnings()) {
+			setTimeout(() => {
+				try {
+					pi.sendMessage(
+						{ customType: "shepherd-agent-end", display: false, content: "" },
+						{ triggerTurn: true },
+					);
+				} catch {
+					/* session 已替换 */
+				}
+			}, 0);
+		}
+	});
+
+	// ── session_shutdown ───────────────────────────────────────
+	pi.on("session_shutdown", async (_event, ctx) => {
+		const rules = loadRules(RULES_DIR, {
+			projectRulesPattern: shepherdConfig.projectRulesPattern,
+		}).filter((r) => r.hook === "session_shutdown");
+		if (rules.length === 0) return;
+		for (const rule of rules) {
+			let shouldNotify = false;
+			if (rule.check === "git_uncommitted") {
+				shouldNotify = hasGitUncommittedChanges();
+			} else if (rule.check === "always" || !rule.check) {
+				shouldNotify = true;
+			}
+			if (shouldNotify && rule.action === "notify") {
+				ctx.ui.notify?.(`⚠️ shepherd: ${rule.reason}`, "warning");
+			}
+		}
+	});
+
+	// ── tool_call + tool_result（提取到 tool-hooks.ts）────────
+	const _rulesOpts = {
+		projectRulesPattern: shepherdConfig.projectRulesPattern,
+	};
+	registerToolCall(pi, _toolState, RULES_DIR, _rulesOpts);
+	registerToolResult(pi, _toolState, RULES_DIR, _rulesOpts);
+
+	// ── shepherd_rules 工具：规则文件安全编辑 ───────────────────
+	registerRulesEditorTool(pi, join(RULES_DIR, "rules.json"));
+}

package/node_modules/@pi-atelier/shared-utils/README.en.md

@@ -0,0 +1,182 @@
+[中文文档](README.md) | English
+
+# pi-shared-utils
+
+Shared utility library for the [pi](https://github.com/earendil-works/pi-coding-agent) extension ecosystem — memory file parsing, path constants, settings management, tool output truncation, and more. Used by 7+ pi extensions.
+
+## Why You Need It
+
+If you're building a pi extension, you'll inevitably need the same building blocks: reading settings, parsing memory files, truncating tool output, finding agent directories. pi-shared-utils provides these as a single dependency so every extension doesn't reinvent the wheel.
+
+**Used by**: pi-memory, pi-context, pi-shepherd, pi-roadmap, pi-session-analyzer, pi-workflow, and more.
+
+## How It Works
+
+```
+pi-shared-utils provides 6 independent modules:
+
+┌─────────────────────────────────────────────────┐
+│  memory-parser  ── parse topic--kw1,kw2.md file names
+│  paths         ── standard pi agent path constants
+│  settings      ── read/write extension config sections in settings.json
+│  tool-output   ── truncate tool output (prevent context overflow)
+│  agents        ── discover sub-agent definition files
+│  ephemeral     ── session-scoped hint/label stack
+└─────────────────────────────────────────────────┘
+```
+
+Each module is independently importable — use only what you need.
+
+## Installation
+
+```bash
+pi install git:github.com/catlain/pi-atelier
+```
+
+> This is a workspace package inside the pi-atelier monorepo and typically doesn't need to be installed standalone. Other independent extensions include it automatically via `bundledDependencies`.
+
+## Exported Modules
+
+### Memory File Parsing (`memory-parser`)
+
+Parses `topic--kw1,kw2,kw3.md`-format memory file names and scans directories to generate an index.
+
+```ts
+import { parseFileName, buildFileName, scanMemoryDir } from "@pi-atelier/shared-utils";
+
+// Parse file name → { topic, keywords }
+const { topic, keywords } = parseFileName("coding_standards--编码,git,lint.md");
+// topic = "coding_standards", keywords = ["编码", "git", "lint"]
+
+// Build file name from parts
+const name = buildFileName("coding_standards", ["编码", "git", "lint"]);
+// "coding_standards--编码,git,lint.md"
+
+// Scan directory, returns MemoryEntry[]
+const entries = await scanMemoryDir("/path/to/memory");
+```
+
+### Path Constants (`paths`)
+
+Standard pi agent paths, so you never hardcode them.
+
+| Constant | Path | Description |
+|------|------|------|
+| `AGENT_DIR` | `~/.pi/agent/` | Agent root directory |
+| `SETTINGS_PATH` | `~/.pi/agent/settings.json` | Global settings |
+| `MODELS_CONFIG_PATH` | `~/.pi/agent/models.json` | Model configuration |
+| `MCP_CONFIG_PATH` | `~/.pi/agent/mcp.json` | MCP server configuration |
+| `MCP_CACHE_PATH` | `~/.pi/agent/mcp-cache/` | MCP tool cache |
+| `AGENTS_DIR` | `~/.pi/agent/agents/` | Sub-agent definitions |
+| `GLOBAL_RULES_PATH` | `~/.pi/agent/rules.md` | Global rules |
+| `MEMORY_DIR` | `~/.pi/agent/memory/` | Global memory |
+| `MEMORY_MD_PATH` | `MEMORY.md` | Memory index file name |
+
+### Settings Management (`settings`)
+
+Read and write extension-specific config sections in `settings.json`.
+
+```ts
+import { getSettingsSection, patchSettingsSection, getSettingsValue, setSettingsValue } from "@pi-atelier/shared-utils";
+
+// Read extension config section
+const config = await getSettingsSection("my-extension");
+
+// Update config incrementally
+await patchSettingsSection("my-extension", { enabled: true });
+
+// Read/write a single value
+const val = await getSettingsValue("my-extension", "key", "default");
+await setSettingsValue("my-extension", "key", "new-value");
+```
+
+### Tool Output Truncation (`tool-output`)
+
+Prevent large tool results from overflowing the LLM context.
+
+```ts
+import { truncateToolOutput, truncatedResult, TOOL_OUTPUT_MAX_LINES } from "@pi-atelier/shared-utils";
+
+// Truncate overly long output
+const result = truncateToolOutput(longText, { maxLines: 200 });
+// { text: "...", truncated: true, originalLines: 1500, keptLines: 200 }
+
+// Shortcut: returns pi tool result format
+return truncatedResult(text);  // auto-truncates + returns { content: [{ type: "text", text }] }
+```
+
+### Sub-Agent Discovery (`agents`)
+
+Scan the `~/.pi/agent/agents/` directory for sub-agent definition files.
+
+```ts
+import { discoverAgents, getAgentDescription, formatAgentsList } from "@pi-atelier/shared-utils";
+
+// Discover all available sub-agents
+const agents = await discoverAgents();
+// [{ name: "pv-executor", description: "...", filePath: "..." }, ...]
+
+// Get description for a single agent
+const desc = await getAgentDescription("pv-executor");
+
+// Format as a readable list
+const list = formatAgentsList(agents);
+```
+
+### Session-Scoped Data (`ephemeral`)
+
+A hint/label stack for the current session that vanishes when the session ends. Useful for lightweight state passing across tool calls.
+
+```ts
+import { pushHint, hasHints, peekHints, drainHints, peekLabels } from "@pi-atelier/shared-utils";
+
+pushHint({ key: "recent-files", values: ["file1.ts", "file2.ts"] });
+const has = hasHints("recent-files");
+const hints = peekHints("recent-files");   // peek without removing
+const all = drainHints();                   // retrieve and clear
+```
+
+## Best Practices
+
+### ✅ Recommended
+- Import only the modules you need to keep bundle size small
+- Use `truncatedResult()` for all tool outputs — prevents context overflow
+- Use `paths` constants instead of hardcoding `~/.pi/agent/...`
+- Use `settings` module for any persistent configuration
+
+### ❌ Not Recommended
+- Don't hardcode pi paths — they may change between versions
+- Don't return raw tool output without truncation
+- Don't use `ephemeral` for persistent data — it's session-scoped only
+
+## Limitations
+
+| Limitation | Detail |
+|------------|--------|
+| Memory file format only | Only supports `topic--kw1,kw2.md` naming convention |
+| No validation | Settings reads don't validate schema — caller must handle |
+| Ephemeral is in-memory | Lost on process restart, not persisted to disk |
+| Token estimation | `tool-output` truncates by lines, not by token count |
+
+## Architecture
+
+```
+pi-shared-utils/
+├── src/
+│   ├── index.ts           # Re-exports all modules
+│   ├── memory-parser.ts   # Memory file name parsing + directory scanning
+│   ├── paths.ts           # Path constants (AGENT_DIR, SETTINGS_PATH, ...)
+│   ├── settings.ts        # settings.json section read/write
+│   ├── tool-output.ts     # Output truncation + truncatedResult helper
+│   ├── agents.ts          # Sub-agent discovery from ~/.pi/agent/agents/
+│   ├── ephemeral.ts       # Session-scoped hint/label stack
+│   └── __tests__/         # Unit tests
+├── package.json
+└── tsconfig.json
+```
+
+**Dependencies**: Zero runtime dependencies (pure Node.js).
+
+## License
+
+MIT