forgehive 0.7.1 → 0.7.2

package/README.md

@@ -14,8 +14,8 @@
 <p align="center">
   <img src="https://img.shields.io/badge/node-%3E%3D18-brightgreen" alt="Node.js ≥ 18">
   <img src="https://img.shields.io/badge/typescript-5.8-blue" alt="TypeScript">
-  <img src="https://img.shields.io/badge/tests-217%20passing-success" alt="217 tests">
-  <img src="https://img.shields.io/badge/bundle-205KB-lightgrey" alt="205KB bundle">
+  <img src="https://img.shields.io/badge/tests-267%20passing-success" alt="267 tests">
+  <img src="https://img.shields.io/badge/bundle-244KB-lightgrey" alt="244KB bundle">
   <img src="https://img.shields.io/badge/license-MIT-green" alt="MIT">
 </p>
 
@@ -31,18 +31,23 @@ Claude loses all project knowledge between sessions. forgehive solves this by wr
 
 - **Stack Scanner** — detects tech stack, dependencies, and project structure automatically
 - **Persistent Memory** — context and session notes survive every restart
+- **Story & Epic Tracking** — lightweight agile backlog inside `.forgehive/memory/`
+- **Velocity Tracking** — sprint velocity history, rolling average, and capacity hints
 - **Party Mode** — specialized agent sets, each agent in its own isolated git worktree
 - **MCP Wiring** — preconfigured connectors for 10 services, API keys stored securely in `~/.forgehive/`
 - **Security Suite** — SAST, secret scanner, CVE check, CISO reports (GDPR/SOC2/HIPAA)
+- **CI Integration** — CI health report and GitHub Actions template generator
+- **Codebase Map** — file/line/import table for navigation and onboarding
+- **Team Sync** — share memory across the team via a dedicated git branch
 - **AGENTS.md** — cross-tool standard (Cursor, Copilot, Gemini CLI, Codex, Windsurf)
 
 **Design principle:** writes exclusively to `.forgehive/` in the target project. No globbing outside the project root. Never overwrites files it didn't create.
 
 ---
 
-## Status: Early Alpha (v0.6)
+## Status: v0.7 — Stable
 
-This is an early release. The codebase is clean — TypeScript, 217 passing tests, single bundle — but several features have not yet been tested against a real project.
+267 passing tests back the commands listed below. The v0.7 feature set has been validated end-to-end.
 
 **Stable — use with confidence:**
 
@@ -56,6 +61,16 @@ This is an early release. The codebase is clean — TypeScript, 217 passing test
 | `fh security report` — compliance reports | stable |
 | `fh memory` — show, clean, export, snapshot | stable |
 | MCP credential store (`fh mcp auth`) | stable |
+| `fh ci` — CI health report + GitHub Actions template | stable |
+| `fh map` — codebase structure map | stable |
+| `fh onboard` — generates ONBOARDING.md | stable |
+| `fh changelog` — semantic changelog from git | stable |
+| `fh metrics` — developer metrics by author/type | stable |
+| `fh sync` — team memory sharing via git branch | stable |
+| `fh run` — background agent execution via `claude -p` | stable |
+| `fh story` — story card create/list/show/done | stable |
+| `fh epic` — epic create/list/show | stable |
+| `fh velocity` — show history + record sprint data | stable |
 
 **Experimental — works in tests, not yet live-validated:**
 
@@ -74,7 +89,7 @@ If you run into issues, please open an issue on GitHub. The most valuable feedba
 
 - **Node.js ≥ 18** — check with `node --version`
 - **Claude Code** installed and configured (`claude` CLI available)
-- **git** — required for Party Mode worktrees and the guardrails hook
+- **git** — required for Party Mode worktrees, `fh sync`, and the guardrails hook
 
 ---
 
@@ -94,14 +109,14 @@ This makes both `fh` and `forgehive` available globally.
 git clone https://github.com/matharnica/forgehive
 cd forgehive
 npm install
-npm run build      # compiles to dist/cli.js (~205 KB)
+npm run build      # compiles to dist/cli.js (~244 KB)
 npm link           # makes 'fh' available globally
 ```
 
 Verify the installation:
 
 ```bash
-fh --version       # should print 0.6.0
+fh --version       # should print 0.7.1
 fh --help          # lists all available commands
 ```
 
@@ -264,6 +279,91 @@ Shows `permissions.yaml` — the file access control list for each agent. Each a
 
 ---
 
+### CI
+
+```bash
+fh ci                          # run CI health report (text output)
+fh ci --format json            # output report as JSON
+fh ci --format markdown        # output report as Markdown
+fh ci --fail-on critical       # exit 1 only on CRITICAL findings
+fh ci --fail-on high           # exit 1 on HIGH or CRITICAL
+fh ci --fail-on any            # exit 1 on any finding
+fh ci --init                   # generate a GitHub Actions workflow template
+```
+
+`fh ci` aggregates security scan, dependency audit, and test results into a single CI health report. Use `--init` to scaffold a `.github/workflows/forgehive.yml` file that runs the full check on every pull request. The `--fail-on` flag controls which severity level causes a non-zero exit code, giving you fine-grained control over what blocks a merge.
+
+---
+
+### Codebase Map
+
+```bash
+fh map
+```
+
+Prints a structured table of your codebase: file paths, line counts, and import relationships. Useful for onboarding a new engineer (or a new Claude session) to an unfamiliar codebase. Output goes to stdout; pipe it to a file if you want to save it.
+
+---
+
+### Onboarding
+
+```bash
+fh onboard                     # generate ONBOARDING.md (stdout)
+fh onboard --output ./ONBOARDING.md   # write to file
+```
+
+Generates a human-readable `ONBOARDING.md` from three sources: the detected stack in `capabilities.yaml`, the persistent memory in `.forgehive/memory/`, and the recent git log. The result is a self-contained document a new team member can read to understand the project architecture, conventions, and current state.
+
+---
+
+### Changelog
+
+```bash
+fh changelog                        # full changelog from all commits
+fh changelog --since v0.6.0         # changes since a specific tag
+fh changelog --output CHANGELOG.md  # write to file
+```
+
+Parses conventional commits (`feat:`, `fix:`, `chore:`, `docs:`, etc.) and groups them into a semantic changelog. Breaking changes are surfaced separately. Requires conventional commit messages — standard for projects that use `fh git-conventions`.
+
+---
+
+### Developer Metrics
+
+```bash
+fh metrics                          # all-time developer metrics
+fh metrics --since 2025-01-01       # metrics since a date
+```
+
+Shows commit activity broken down by author and commit type (feat, fix, chore, docs, test, refactor). Also shows rolling statistics: commit frequency, most active contributors, and type distribution. Useful for retrospectives and identifying contribution patterns.
+
+---
+
+### Team Memory Sync
+
+```bash
+fh sync push                                           # push memory to default remote/branch
+fh sync push --remote origin --branch forgehive-memory  # push to a specific remote branch
+fh sync pull                                           # pull memory from remote
+fh sync pull --remote origin --branch forgehive-memory  # pull from specific branch
+```
+
+`fh sync` shares `.forgehive/memory/` across the team by pushing to (or pulling from) a dedicated git branch. This is an alternative to committing the memory directory into the main branch. On `pull`, existing local files are not overwritten — only new files are added, the same idempotent behavior as `fh memory snapshot import`.
+
+---
+
+### Background Agent Execution
+
+```bash
+fh run <issue-url>                         # run agent on a GitHub/Linear issue URL
+fh run <issue-url> --agent kai             # use a specific agent
+fh run <issue-url> --label ready-for-ai   # filter by label
+```
+
+`fh run` launches a background agent via `claude -p`, passes the issue content as context, and returns immediately. The agent reads the issue, applies forgehive context from `.forgehive/`, and works on the task in the background. Useful for automating repetitive issues or running agents overnight. Agent output is streamed to stdout and also written to `.forgehive/runs/`.
+
+---
+
 ### Memory
 
 Memory files live in `.forgehive/memory/` and are read by Claude at session start via the CLAUDE.md block.
@@ -297,6 +397,55 @@ Memory files live in `.forgehive/memory/` and are read by Claude at session star
 
 ---
 
+### Story Cards
+
+Story cards are lightweight user stories stored in `.forgehive/memory/stories/`. They integrate with `/fh-sprint` for velocity-based sprint planning.
+
+```bash
+fh story create "As a user I want to log in"            # create a story (auto-numbered US-N)
+fh story create "As a user I want to log in" --epic EPC-1 --points 3   # with epic + points
+fh story list                                            # list all backlog stories
+fh story list --epic EPC-1                              # filter by epic
+fh story show US-1                                       # show full story card with acceptance criteria
+fh story done US-1                                       # mark story as done
+fh story done US-1 --points 5                           # mark done and record actual points
+```
+
+Each story card is a Markdown file at `.forgehive/memory/stories/US-N.md`. The card includes a title, acceptance criteria placeholder, story points, epic link, and status (`backlog` | `done`). When you run `/fh-sprint` in a Claude Code session, Claude reads the backlog and uses velocity data to suggest a realistic sprint scope.
+
+---
+
+### Epics
+
+Epics group related stories and are stored in `.forgehive/memory/epics/`.
+
+```bash
+fh epic create "User Authentication"                              # create an epic (auto-numbered EPC-N)
+fh epic create "User Authentication" --goal "Users can log in securely"  # with a goal statement
+fh epic list                                                       # list all epics
+fh epic show EPC-1                                                 # show epic with linked stories and point total
+```
+
+Each epic card is a Markdown file at `.forgehive/memory/epics/EPC-N.md`. `fh epic show` aggregates all stories linked to the epic and displays their status and point totals.
+
+---
+
+### Velocity
+
+```bash
+fh velocity show                                              # velocity history + rolling average + recommendation
+fh velocity record sprint-3 --committed 21 --delivered 18    # record sprint data
+```
+
+`fh velocity show` reads the velocity history from `.forgehive/memory/velocity.md` and prints:
+- A table of past sprints (committed vs. delivered points)
+- A rolling average (last 3 sprints)
+- A capacity recommendation for the next sprint
+
+`fh velocity record` appends a new entry to the velocity history. The `/fh-sprint` slash command reads this data automatically and uses it to calibrate the sprint scope it suggests.
+
+---
+
 ### Party Mode
 
 Party Mode runs specialized agent sets in parallel, each in an isolated git worktree.
@@ -320,7 +469,7 @@ fh party cleanup            # remove finished worktrees
 | `security` | Vera + Sam | `/security-party` |
 | `full` | All 8 agents | `/full-party` |
 
-**Model mapping** — assign specific Claude models per agent:
+**Multi-model routing** — `defaults.yaml` supports a `models:` key per agent set. Override via CLI:
 
 ```bash
 fh party --model-map "viktor:claude-opus-4-7,kai:claude-sonnet-4-6,sam:claude-haiku-4-5"
@@ -417,33 +566,57 @@ Clones the repo with `--depth=1`, copies all `.md` files from the `skills/expert
 
 ---
 
+### Slash Commands
+
+The following slash commands are available inside Claude Code sessions:
+
+| Command | Description |
+|---|---|
+| `/fh-sprint` | Sprint planning — reads backlog, velocity, and capacity; suggests scope using Fibonacci points (1/2/3/5/8/13); records velocity at end of sprint |
+| `/fh-deploy` | Pre-deploy checklist — security scan, dependency audit, test run, final confirmation |
+| `/fh-test-this` | Generate tests for the current file or selection — uses `testing-strategies` skill |
+| `/fh-docs` | Generate documentation for the current file or module |
+| `/party` | Start the `build` party (Viktor + Kai + Sam) |
+| `/design-party` | Start the `design` party (Suki + Viktor) |
+| `/review-party` | Start the `review` party (Kai + Sam + Eli) |
+| `/security-party` | Start the `security` party (Vera + Sam) |
+| `/full-party` | Start all 8 agents |
+
+**`/fh-sprint` in detail:** Reads `.forgehive/memory/stories/` for backlog items, `.forgehive/memory/velocity.md` for historical capacity, and `.forgehive/memory/epics/` for epic context. Suggests a sprint scope as a list of story cards with Fibonacci point estimates. When you close the sprint, it prompts you to record delivered points so velocity history stays up to date. If Linear or GitHub MCP servers are connected, it can pull issues directly from those services.
+
+---
+
 ## What `fh init` Creates
 
 ```
 my-project/
   .forgehive/
-    capabilities.yaml          ← detected stack (status: draft → confirmed)
-    scan-result.yaml           ← raw scanner output
-    .scan-hash                 ← checksum for fh scan --check
+    capabilities.yaml          <- detected stack (status: draft -> confirmed)
+    scan-result.yaml           <- raw scanner output
+    .scan-hash                 <- checksum for fh scan --check
     harness/
-      architecture.md          ← codebase overview for Claude
-      constraints.yaml         ← max_lines, require_tests, style rules
-      permissions.yaml         ← per-agent file access control (read/write/deny)
+      architecture.md          <- codebase overview for Claude
+      constraints.yaml         <- max_lines, require_tests, style rules
+      permissions.yaml         <- per-agent file access control (read/write/deny)
     memory/
-      MEMORY.md                ← index of all memory files
-      project.md               ← project context and open decisions
-      feedback.md              ← corrections + confirmed approaches
-      stack.md                 ← stack details the scanner can't detect
-      adrs/                    ← architecture decision records
+      MEMORY.md                <- index of all memory files
+      project.md               <- project context and open decisions
+      feedback.md              <- corrections + confirmed approaches
+      stack.md                 <- stack details the scanner can't detect
+      adrs/                    <- architecture decision records
+      stories/                 <- story cards (US-N.md)
+      epics/                   <- epic cards (EPC-N.md)
+      velocity.md              <- sprint velocity history
     skills/
-      generated/               ← AI-generated skills (fh skills regen)
-      expert/                  ← 16 preinstalled expert skills
-      workflows/               ← MCP workflow skills
-    worktrees/                 ← isolated git worktrees (fh party run)
-    audit.log                  ← JSONL audit trail (fh security commands)
-    cost-config.yaml           ← spend limits (fh cost --limit/--alert)
-  AGENTS.md                    ← cross-tool agent standard
-  CLAUDE.md                    ← forgehive block inserted, rest preserved
+      generated/               <- AI-generated skills (fh skills regen)
+      expert/                  <- 16 preinstalled expert skills
+      workflows/               <- MCP workflow skills
+    worktrees/                 <- isolated git worktrees (fh party run)
+    runs/                      <- background agent output (fh run)
+    audit.log                  <- JSONL audit trail (fh security commands)
+    cost-config.yaml           <- spend limits (fh cost --limit/--alert)
+  AGENTS.md                    <- cross-tool agent standard
+  CLAUDE.md                    <- forgehive block inserted, rest preserved
 ```
 
 ---
@@ -520,7 +693,7 @@ The hook fires on every bash command execution in Claude Code and exits 1 if a m
 cd my-project
 fh init
 fh confirm
-# Open Claude Code → Claude now has full context
+# Open Claude Code -> Claude now has full context
 ```
 
 ### After adding new dependencies
@@ -539,6 +712,49 @@ fh security deps            # check for new CVEs in dependencies
 fh security report gdpr     # update compliance report
 ```
 
+### CI integration
+
+```bash
+fh ci --init                  # scaffold .github/workflows/forgehive.yml
+fh ci --format markdown --fail-on high   # use in existing CI scripts
+```
+
+### Generating onboarding documentation
+
+```bash
+fh map                        # review codebase structure
+fh onboard --output ONBOARDING.md   # generate onboarding document
+git add ONBOARDING.md
+git commit -m "docs: add forgehive-generated onboarding"
+```
+
+### Generating a changelog
+
+```bash
+fh changelog --since v0.6.0 --output CHANGELOG.md
+```
+
+### Sprint planning
+
+```bash
+# Set up your backlog
+fh epic create "User Authentication" --goal "Users can log in securely"
+fh story create "As a user I want to log in" --epic EPC-1 --points 3
+fh story create "As a user I want to reset my password" --epic EPC-1 --points 2
+
+# Check current velocity
+fh velocity show
+
+# Open Claude Code and run:
+# /fh-sprint
+# Claude reads velocity + backlog and suggests scope
+
+# At end of sprint
+fh velocity record sprint-1 --committed 13 --delivered 11
+fh story done US-1
+fh story done US-2
+```
+
 ### Sharing context with the team
 
 ```bash
@@ -548,6 +764,11 @@ git commit -m "chore: update shared forgehive context"
 
 # On another machine:
 fh memory snapshot import ./team-context.json
+
+# Or use the sync approach (no committed file):
+fh sync push --remote origin --branch forgehive-memory
+# teammate runs:
+fh sync pull --remote origin --branch forgehive-memory
 ```
 
 ### Starting a multi-agent build session
@@ -555,8 +776,8 @@ fh memory snapshot import ./team-context.json
 ```bash
 fh party --set build
 fh party run
-# → Creates worktrees for Viktor (architect), Kai (engineer), Sam (QA)
-# → Each Claude Code session opens in its own isolated worktree
+# -> Creates worktrees for Viktor (architect), Kai (engineer), Sam (QA)
+# -> Each Claude Code session opens in its own isolated worktree
 
 fh party status     # check what's running
 fh party cleanup    # clean up after the session
@@ -575,6 +796,14 @@ fh mcp auth add github GITHUB_TOKEN=ghp_...
 fh mcp auth list    # verify both services are stored
 ```
 
+### Running a background agent on an issue
+
+```bash
+fh run https://github.com/my-org/my-repo/issues/42 --agent kai
+# Kai reads the issue, applies forgehive context, works in background
+# Output streamed to stdout and saved to .forgehive/runs/
+```
+
 ---
 
 ## Configuration Files
@@ -613,13 +842,13 @@ Global credential store (chmod 600). Managed exclusively via `fh mcp auth` comma
 |---|---|
 | Runtime | Node.js ≥ 18, ESM |
 | Language | TypeScript |
-| Build | esbuild → `dist/cli.js` (~205 KB, single bundle) |
+| Build | esbuild -> `dist/cli.js` (~244 KB, single bundle) |
 | Type check | `tsc --noEmit` |
-| Tests | `node:test` (native) + tsx ESM loader, 217 tests |
+| Tests | `node:test` (native) + tsx ESM loader, 267 tests |
 | Dependencies | `js-yaml` (sole runtime dependency) |
 
 ```bash
-npm run build       # esbuild → dist/cli.js
+npm run build       # esbuild -> dist/cli.js
 npm run typecheck   # tsc --noEmit
 npm test            # node --import tsx/esm --test test/*.test.ts
 ```

package/dist/cli.js

@@ -6459,7 +6459,75 @@ var [, , command, subcommand, ...rest] = process.argv;
 var projectRoot = process.cwd();
 var forgehiveDir = path31.join(projectRoot, ".forgehive");
 if (command === "--version" || command === "-v") {
-  console.log("0.7.1");
+  console.log("0.7.2");
+  process.exit(0);
+}
+if (command === "--help" || command === "-h" || command === "help") {
+  console.log(`
+forgehive v0.7.2 \u2014 Context-aware AI development environment
+
+USAGE
+  fh <command> [subcommand] [options]
+
+SETUP
+  fh init                          Set up forgehive in the current project
+  fh confirm                       Activate capabilities (draft \u2192 confirmed)
+  fh rollback                      Remove forgehive from the project
+  fh status                        Show current project state
+  fh scan --update                 Re-scan project after changes
+  fh scan --check                  Check if scan is still current
+
+SECURITY
+  fh security scan                 Secrets + SAST scan
+  fh security deps                 CVE check (npm audit)
+  fh security report [gdpr|soc2|hipaa]  Compliance report
+  fh security audit                Show audit trail
+  fh security permissions          Show agent file permissions
+
+CI
+  fh ci                            Run CI health report
+  fh ci --format json|markdown     Output format
+  fh ci --fail-on critical|high|any  Failure threshold
+  fh ci --init                     Generate GitHub Actions workflow
+
+CODEBASE
+  fh map                           Codebase structure map
+  fh onboard [--output path]       Generate ONBOARDING.md
+  fh changelog [--since tag]       Semantic changelog from git
+  fh metrics [--since date]        Developer productivity metrics
+
+SPRINT PLANNING
+  fh story create <title> [--epic EPC-N] [--points N]
+  fh story list [--epic EPC-N]
+  fh story show <US-N>
+  fh story sprint <US-N>           Mark story as in-sprint
+  fh story done <US-N> [--points N]
+  fh epic create <title> [--goal <text>]
+  fh epic list
+  fh epic show <EPC-N>
+  fh velocity show                 Velocity history + rolling average
+  fh velocity record <N> --committed N --delivered N
+
+TEAM
+  fh sync push|pull [--remote origin --branch forgehive-memory]
+  fh run <issue-url> [--agent name] [--label label]
+  fh memory show|clean|export|prune|snapshot
+  fh memory adr list|"<title>"
+
+AGENTS & MCP
+  fh party [--set name|run|status|cleanup]
+  fh wire <service>                Configure MCP server
+  fh mcp auth add|list|remove      Manage credentials
+  fh mcp search <query>            Search MCP registry
+  fh skills list|regen|pull <url>
+
+COST
+  fh cost [today|week|all]
+  fh cost --limit N --alert N
+
+  fh --version                     Show version
+  fh --help                        Show this help
+`);
   process.exit(0);
 }
 function loadClaudeMdBlock() {
@@ -6474,6 +6542,13 @@ function loadClaudeMdBlock() {
   return fs30.readFileSync(templatePath, "utf8");
 }
 if (command === "init") {
+  const forgehiveDirExists = fs30.existsSync(forgehiveDir);
+  if (forgehiveDirExists && !rest.includes("--force")) {
+    console.log(`\u26A0 .forgehive/ existiert bereits in diesem Projekt.`);
+    console.log(`  Nutze 'fh init --force' um neu zu initialisieren (\xFCberschreibt capabilities.yaml).`);
+    console.log(`  Nutze 'fh scan --update' um nur den Scan zu aktualisieren.`);
+    process.exit(0);
+  }
   console.log("\u{1F50D} Analysiere Projekt...\n");
   const scanResult = scan(projectRoot);
   const tierCount = [1, 2, 3].map((t) => scanResult.signals.filter((s) => s.tier === t).length);
@@ -7264,6 +7339,14 @@ Setze diese Umgebungsvariablen:`);
     if (pointsArg) updateStoryPoints(storiesDir, id, pointsArg);
     updateStoryStatus(storiesDir, id, "done");
     console.log(`\u2714 ${id} als done markiert`);
+  } else if (subcommand === "sprint") {
+    const id = rest[0];
+    if (!id) {
+      console.error("Usage: fh story sprint <US-N>");
+      process.exit(1);
+    }
+    updateStoryStatus(storiesDir, id, "in-sprint");
+    console.log(`\u2714 ${id} in Sprint gezogen`);
   } else if (subcommand === "show") {
     const id = rest[0];
     if (!id) {
@@ -7328,14 +7411,16 @@ Setze diese Umgebungsvariablen:`);
     recordVelocity(velocityFile, sprintNum, committed, delivered);
     const avg = getRollingAverage(getVelocityHistory(velocityFile));
     console.log(`\u2714 Sprint ${sprintNum} gespeichert. Rolling Average: ${avg} Punkte`);
-  } else {
+  } else if (!subcommand || subcommand === "show") {
     const history = getVelocityHistory(velocityFile);
     console.log(formatVelocityReport(history));
+  } else {
+    console.error("Verf\xFCgbar: fh velocity show | record <N> --committed N --delivered N");
   }
 } else {
-  const cmd = [command, subcommand].filter(Boolean).join(" ") || "(kein)";
-  console.error(`Unbekannter Befehl: ${cmd}`);
-  console.error("Verf\xFCgbar: init | confirm | rollback | scan --update | scan --check | status | ci [--format json|markdown] [--fail-on critical|high|any] [--init] | map | onboard [--output path] | changelog [--since tag] | metrics [--since date] | sync [push|pull] [--remote origin --branch forgehive-memory] | run <issue-url> [--agent <name>] | cost [today|week|all] | cost --limit N --alert N | memory [show|clean|export|prune|snapshot] | memory adr [list|<titel>] | skills [list|regen|pull <url>] | party [--set <name>|run|status|cleanup] | wire <service> | mcp [auth|search|add] | security [scan|deps|report|audit|permissions]");
+  console.error("Unbekannter Befehl: " + command);
+  console.error("Verf\xFCgbar: init | confirm | rollback | scan | status | ci | map | onboard | changelog | metrics | story [create|list|show|sprint|done] | epic [create|list|show] | velocity [show|record] | sync [push|pull] | run <issue-url> | cost | memory | skills | party | wire | mcp | security");
+  console.error("Hilfe: fh --help");
   process.exit(1);
 }
 /*! Bundled license information:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forgehive",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "description": "Context-aware AI development environment — one binary, your stack.",
   "type": "module",
   "bin": {