nearly-cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anuj Patel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,274 @@
+# Nearly
+
+**A pull request tells you what changed. This tells you what nearly happened.**
+
+When a coding agent writes a branch, the person reviewing it has no idea what the agent tried, what a human refused, or what got rolled back. The diff is the only thing that survives, and the diff is the one artifact that cannot show you any of it.
+
+Nearly holds an agent's risky actions until a human decides, records every one of those decisions, and turns the branch into a short narrated page written for **the reviewer**. That page is a link, and it goes on the pull request.
+
+```
+you work normally  →  agent acts  →  risky action held  →  you decide
+                                                              ↓
+   reviewer opens the PR  ←  comment posted  ←  you push  ←  recorded
+```
+
+## Look before you install anything
+
+Nothing to run. This is a real record from two real agent sessions on one branch:
+
+**[A branch where three things never happened →](https://anujpatel06.github.io/nearly/records/priya-app--feat-third-task.html)**
+
+Watch the first thirty seconds. The cover says what the diff cannot: an action the supervisor refused, a push policy blocked, and a file deletion refused. [Here is how it looks on the pull request.](https://github.com/anujpatel06/tempo-demo/pull/2)
+
+## What it needs
+
+Node 18 or newer, Claude Code signed in, and git. No dependencies and no API key: agents run on your existing Claude subscription.
+
+Gating, recording and the record itself work on macOS, Linux and Windows. **Spoken narration is macOS only**, because it uses the built-in `say`. Elsewhere the record is built the same way and reads from its captions, or you can supply your own recordings with `--voice-dir`.
+
+## Use it on your own repo
+
+One command, in the repo you want recorded.
+
+```bash
+cd ~/code/my-app
+nearly
+```
+
+```
+✓ Nearly is on for my-app
+
+  · every Claude Code session here is gated and recorded
+  · the record is offered when you push
+  · records publish to https://you.github.io/nearly/records
+
+  Now just work. Requests that need you appear at http://127.0.0.1:47653
+  Nothing to leave running. Turn it off again with --off.
+```
+
+It installs the Claude Code hooks and the git pre-push hook, and works out where records publish by reading the Nearly's own remote. Nothing to configure. `nearly off` removes all of it.
+
+**To get that command,** until this is on npm:
+
+```bash
+git clone https://github.com/anujpatel06/nearly ~/nearly
+npm link --prefix ~/nearly
+```
+
+No dependencies, so the link is instant. Once published it becomes `npx nearly-cli` with nothing to clone at all.
+
+### Upgrading
+
+It updates itself. When you run a command and a newer version exists, Nearly
+installs it and tells you it did, then every repo you turned it on for is on the
+new version with nothing to turn on again.
+
+Four rules keep that from being something you regret installing:
+
+- **Never in the hook path.** Nothing about updating may sit in front of an
+  action an agent is waiting on. Only commands you typed can trigger it, and
+  there is a test asserting the hook file does not even import the updater.
+- **Never across a major version.** Nearly decides whether `rm -rf` runs. Same
+  major means same promises; a major bump is announced and left for you to read
+  before you trust it.
+- **Never silent.** An update that happened without being mentioned is
+  indistinguishable from a compromise, so it always says what it did.
+- **Never fatal.** No network, a locked global directory, a slow registry: you
+  keep the version you have, the command you ran still works, and it tells you
+  rather than leaving you to assume you are current.
+
+It checks once a day, not on every command. `NEARLY_NO_UPDATE=1` turns it off
+for good. Running through `npx` or from a checkout, it tells you instead of
+touching anything, because an npx run is ephemeral and a checkout is yours.
+
+**There is no server to start.** The hooks start it the first time they need it, in about a second, and it stays up. If it cannot start, Claude Code falls back to its own permission prompts and your session continues. Nothing to remember and nothing to break.
+
+## Then work normally
+
+Nothing about how you work changes. Open the repo in VS Code or a terminal, start Claude Code, give it a task.
+
+1. **Reads run silently.** Anything that only looks at your code is allowed and logged.
+2. **Anything that changes or reaches out is held.** It appears at http://127.0.0.1:47653 with the command, what it can affect, and a countdown. Answer with `A` or `D`, or shift for always and never. Nobody answering means denied after two minutes.
+3. **The record builds itself** when the session ends.
+4. **At `git push`** the hook merges every session on that branch, prints what was refused, and asks whether to post it. Say no and the push just continues.
+5. **Your reviewer opens the pull request** and the record is there, as one comment that updates on every push rather than a new one each time.
+
+### For a team
+
+`.claude/settings.local.json` is per-person and stays out of git, which is right while you are trying it. To turn it on for everyone, move the same hooks into `.claude/settings.json` and commit that file. Once this is on npm the hooks invoke `npx nearly-cli`, so a teammate who clones the repo needs nothing installed beyond Node.
+
+## Why the gate is not the point
+
+Gating agent tool calls is a solved problem and several teams do it better:
+
+- **[Prempti](https://prempti.falco.org/)** (Falco, CNCF, Apache 2.0) runs a real rule engine over every tool call, with policies in ordinary Falco YAML and a monitor mode for tuning them. Its homepage promises "a story of the session, not just the diff" — then ships that story as a local log file with no viewer.
+- **[Agent Approve](https://www.agentapprove.com/)** puts each approval on your Apple Watch across twelve different agents, and parses chained shell commands so a dangerous one cannot hide behind a safe one. When the session ends it leaves no artifact at all.
+- **[Endor Labs](https://www.endorlabs.com/)** streams every action into a searchable audit trail for enterprise security teams, and can rewrite a command before it runs. What it posts on your pull request is security findings about the code, never the story of the session.
+- Claude Code, Cursor, Antigravity, Warp, Devin and Goose all ship their own allow/deny/ask lists, and Anthropic's **auto mode** now lets a classifier decide, on the evidence that users approve 93% of the prompts they see.
+
+All of them capture the moment a human refuses something. None of them passes it on. Prempti writes it to a log for a security engineer, Agent Approve shows it to one person on a watch, Endor files it for an auditor.
+
+**The gate here exists to produce the recording.** It is the instrument, not the product. If you already run Prempti, its audit trail is richer than ours and reading it as an input is the obvious next step; see *Roadmap*.
+
+## The consent gradient
+
+Every tool call passes through an HTTP `PreToolUse` hook to this server, which sorts it into a tier:
+
+| Tier | What happens | Default for |
+|---|---|---|
+| never | denied, no prompt, logged | `rm -rf`, `git push`, `sudo`, `.env`, `curl … | sh` |
+| ask | held until a human decides in the UI; denied if nobody answers in 2 minutes (fails closed) | Bash, Edit, Write, WebFetch, Task |
+| log | allowed, receipt recorded | Read, Glob, Grep |
+
+"Allow always" and "Never" turn a decision into a rule for the rest of the run, keyed by tool and first word of the command, or file extension for edits. In lab mode every turn is committed in the agent's worktree by the `Stop` hook, so **Undo turn** is a `git reset --hard HEAD~1`.
+
+Agents in lab mode are real Claude Code sessions (`claude -p`) on your Claude subscription, each in its own git worktree under `workspace/.worktrees/`. No API key, no paid infrastructure, anywhere in this project.
+
+## What the record actually contains
+
+**Who it is for.** The reviewer, who was not in the room. So the narration names the supervisor rather than saying "you", and it leads with the actions that never happened. Pass `--audience supervisor` for the second-person version.
+
+Scene by scene: the task verbatim, every held request with the answer given and how long it took, each round of changes as a diff, anything rolled back, and one closing view of what was asked against what the agent claims it did. Every figure is computed from the recording.
+
+The push hook builds this for you. To build one by hand:
+
+```bash
+node scripts/build-recap.mjs --branch feat/x --repo ~/code/my-app   # a branch
+node scripts/build-recap.mjs latest                                 # one session
+node scripts/build-recap.mjs latest --llm                           # Claude rewrites the sentences, never the facts
+```
+
+Output is one self-contained HTML file in `ui/records/`, served at `/records/…` while the server runs.
+
+### The voice
+
+macOS ships three tiers of every voice. The **compact** one is installed by default and is the robot everyone recognises. **Enhanced** and **Premium** are free downloads and sound dramatically better:
+
+```
+System Settings → Accessibility → Spoken Content → System Voice → Manage Voices
+```
+
+The builder picks the best tier it finds and tells you when all it has is compact. See what you have:
+
+```bash
+node scripts/build-recap.mjs --voices
+node scripts/build-recap.mjs latest --voice "Ava (Premium)"
+```
+
+**Better still, read it yourself.** Synthesis is a stand-in for a person reading their own words, and for the one record you put in front of people it is worth ten minutes:
+
+```bash
+node scripts/build-recap.mjs latest --script          # writes records/<slug>-script.md
+# record each numbered line into a folder as 01.m4a, 02.m4a, …
+node scripts/build-recap.mjs latest --voice-dir ~/Desktop/narration
+```
+
+Lines you have not recorded fall back to the system voice, so you can do them a few at a time.
+
+Rules the builder follows:
+
+- Every number, diff and decision is computed from `recordings/<session>.jsonl` and the worktree's git history. With `--llm`, Claude only rewrites the narration sentences; it cannot add or change a fact, and the page says which mode produced it.
+- Narration is macOS `say` converted to AAC and embedded, so the file needs no server and no API key. About 6 KB per second of speech.
+- The storyboard is also written to `records/<agent>-<id>.json` for inspection.
+
+## The branch is the unit, not the session
+
+A reviewer opens a pull request, not a session. One branch collects several agent sessions over days, so the record merges all of them, numbering each instruction in order. A branch record supersedes the per-session records inside it, so the published index never shows the same story twice.
+
+## Hand it over at push time
+
+Pushing is the moment the work stops being yours and becomes someone else's to
+review, so that is when the record should change hands.
+
+```bash
+node scripts/install-push-hook.mjs ~/code/my-app
+```
+
+That installs a `pre-push` hook. On your next push it builds the branch record,
+prints what it found including anything refused, and — only if there is an open
+pull request — asks whether to post it. Answer `y` and it comments; anything else
+and the push just continues.
+
+Three rules it follows:
+
+- **It never blocks a push.** No sessions on the branch, no server, a crash, a
+  timeout: it prints one dim line at most and exits 0.
+- **It never posts without you.** A record of what you refused is more revealing
+  than a diff. Publishing that to a shared pull request is your call, every time.
+- **It stays fast.** Narration is skipped by default, because a minute of `say`
+  at every push is not acceptable. Set `NEARLY_AUDIO=1` when you want the good one.
+
+Set `NEARLY_URL_BASE` to the hosted path so the comment can link to the page:
+
+```bash
+export NEARLY_URL_BASE=https://<user>.github.io/<repo>/records
+```
+
+Today the poster speaks GitHub, through the `gh` CLI. Bitbucket and GitLab each
+need their own small poster; the record itself is provider-agnostic, since it is
+just a hosted page and a link.
+
+## Publish the records
+
+Recap pages are self-contained HTML, so GitHub Pages hosts them for free and the links in pull request comments resolve for anyone who can see the repo.
+
+```bash
+node scripts/publish-pages.mjs --base https://<user>.github.io/<repo>
+```
+
+That copies every built recap into `docs/records/` and writes `docs/index.html`, an index of the sessions on record. Commit `docs/`, then set **Settings → Pages → branch `main`, folder `/docs`**. Preview it locally first at http://127.0.0.1:47653/docs/ while the server is running.
+
+## Why the hook fails open
+
+Claude Code treats a hook that times out, errors, or returns anything other than `200` with JSON as a non-blocking error and lets the tool call proceed. So this server always answers with JSON, holds "ask" calls for at most `ASK_TIMEOUT_MS`, and denies when nobody decides. The hook's own timeout is set longer than that.
+
+## Tests
+
+```bash
+npm test
+```
+
+41 tests, no dependencies, about 30 seconds. They run on a fresh clone with no
+agent, no network and no Claude subscription, because the fixtures are the two
+recorded sessions committed in `recordings/demo`.
+
+What they hold the project to:
+
+- **The consent gradient.** That destructive commands are denied without asking,
+  that a never pattern still fires when the command is buried in a chain, that an
+  unclassified tool is held rather than allowed, and that "always" for `git status`
+  can never become permission for `git push`.
+- **The hook contract.** The exact JSON Claude Code reads, for every tier. That an
+  ask really is held until somebody answers, and that **nobody answering means
+  denied**, which is the assumption the whole design rests on.
+- **The record's central claim.** That every figure on the page matches the
+  recording: the refusal count, who refused each one, every instruction verbatim
+  and in order. The test reads the recordings itself rather than trusting the
+  builder's own summary.
+- **The failure paths**, which are the ones that lose you a user silently. That a
+  hook whose server cannot start stays quiet and exits 0 rather than wedging a
+  session. That two hooks racing for the port do not crash. That turning it on
+  twice installs nothing twice, turning it off removes everything, and neither
+  touches settings somebody else put there.
+
+## Study
+
+The claim this project makes is testable: a reviewer who sees the session record catches something a reviewer who sees only the diff misses. [`STUDY.md`](STUDY.md) is the protocol — two seeded-error tasks, three participants, and rules for reporting the result honestly including when it is negative.
+
+## Roadmap
+
+- **Read Prempti's audit trail as an input.** Their recording is structured, local, Apache-licensed and covers more than ours. The recap builder reads its own JSONL today; a second reader would let anyone already running Prempti get a session record without changing their gate.
+- **A Cursor adapter.** The server speaks JSON in and JSON out, so a tool that runs a script instead of calling a URL needs about twenty lines of translation. Cursor's `beforeShellExecution` is the first target.
+- **Port the recap player to React.** It is one self-contained page today.
+
+## Files
+
+- `server/index.mjs`, spawn sessions, hooks, policy, recorder, undo
+- `ui/index.html`, sessions, triage of pending approvals, rules, log
+- `scripts/attach.mjs`, install or remove the hooks in a repo of your own; `scripts/post-recap.mjs`, comment the recap on its PR
+- `scripts/build-recap.mjs` + `ui/recap.template.html`, narrated recap page per session
+- `scripts/publish-pages.mjs`, build the `docs/` folder GitHub Pages serves
+- `scripts/install-push-hook.mjs` + `scripts/push-record.mjs`, hand the branch record over at `git push`
+- `workspace/`, the repo agents work on (seeded with the Tempo demo)
+- `recordings/<session>.jsonl`, every event and decision; `recordings/demo/` is committed so the records can be rebuilt from source
+- `STUDY.md`, the protocol for testing whether any of this helps a reviewer

package/STUDY.md

@@ -0,0 +1,101 @@
+# Seeded-error study
+
+**The claim to test:** a reviewer who sees the session record catches something a reviewer who sees only the diff misses.
+
+Nobody in this space has published evidence that their surface changes what a person catches. Prempti, Agent Approve and Endor Labs all ship a product; none of them ships a number. This is the cheapest thing on the schedule that cannot be copied in a sprint.
+
+Three participants, twenty minutes each, no incentives, run in person or over a call with screen share.
+
+---
+
+## Design
+
+Within-subject, two tasks per participant, order counterbalanced.
+
+| | Condition A, control | Condition B, treatment |
+|---|---|---|
+| What they get | The pull request: title, description, diff | The same pull request, plus a link to the session record |
+| What they do | Decide: approve, request changes, or block | Same |
+
+Each participant does one task in each condition. Participant 1 gets A then B, participant 2 gets B then A, participant 3 gets A then B. With three people this does not remove order effects, it only stops them all pointing the same way. Say so in the write-up.
+
+**Do not tell participants what the study is about.** Say: "you are reviewing a branch a coding agent wrote; decide whether to approve it." Nothing about refusals, nothing about Nearly.
+
+---
+
+## The two tasks
+
+Both run against the demo workspace. Both produce a diff that looks correct and passes a glance. The planted problem is not in the diff.
+
+### Task 1 — the unrun test
+
+The agent is asked to change behaviour **and run the test suite to confirm**. The supervisor refuses the test command. The agent edits the code correctly and reports honestly that tests did not run.
+
+- **Diff shows:** a clean, plausible code change.
+- **Diff hides:** that the change was never verified, because the verification step was refused.
+- **Catch condition:** the participant says, unprompted, that the change is unverified or that tests did not run.
+
+### Task 2 — the rolled-back turn
+
+The agent makes two rounds of changes. The supervisor undoes the second. The branch ends in a state that looks deliberate.
+
+- **Diff shows:** the surviving change only.
+- **Diff hides:** that the agent tried a second approach which a human threw away, and why that matters for the reviewer's suggestion to "just also do X".
+- **Catch condition:** the participant mentions that something was attempted and reverted, or asks what else was tried.
+
+Record both sessions once and reuse the recordings for all three participants, so every participant sees identical material. Build with `--audience reviewer`, which is the default.
+
+---
+
+## Script
+
+Read this aloud, the same way each time.
+
+> You are reviewing a branch that a coding agent wrote. Another engineer supervised the agent while it worked. Take as long as you need, think out loud, and at the end tell me whether you would approve it, request changes, or block it.
+
+Then, in the treatment condition only, add:
+
+> There is also a link to a record of the session in the pull request comment. Use it or ignore it, whichever you would normally do.
+
+Say nothing else. Do not point at the refusals. If they ask what the record is, say "have a look and tell me."
+
+---
+
+## What to write down
+
+For each task, per participant:
+
+| Field | How to record it |
+|---|---|
+| Condition | A or B |
+| Caught the planted problem | yes / no, and the exact words they used |
+| Time to decision | stopwatch, from start to their verdict |
+| Opened the record (B only) | yes / no, unprompted or after the prompt |
+| Verdict | approve / request changes / block |
+| Quote | one sentence in their words worth publishing |
+
+The headline number is the first row: how many of three caught it with the record, how many without.
+
+---
+
+## Reporting honestly
+
+With three people this is a **usability test, not an experiment**. Write it up that way:
+
+- Report the raw count, never a percentage. "Two of three caught it with the record, none of three without" is honest. "67% improvement" is not.
+- Report participants who caught it for the wrong reason as misses of the design, not hits.
+- If the record does not help, say so and publish it anyway. A negative result honestly reported is still evidence you ran the test, and it is more interesting than another feature.
+- Note every confound: three people, order effects, the author present, participants who know what the project is.
+
+The essay sentence to aim for is a fact, not a claim: *given the same branch, N of three reviewers noticed the refused test run with the record, and N without.*
+
+---
+
+## Before the session
+
+- [ ] Both recordings captured with a real agent, not simulated
+- [ ] Both records built and reachable at a public link
+- [ ] Both pull requests open, with the recap comment posted on the treatment one
+- [ ] Recap opens in under two seconds on a cold load
+- [ ] Practice run with someone who is not a participant, to fix the script
+- [ ] Stopwatch, and a written sheet per participant, not memory

package/bin/nearly.mjs

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+// The one command. Everything else is a subcommand of this.
+//
+//   nearly              turn it on for the repo you are in
+//   nearly off          turn it off again
+//   nearly open         open the dashboard
+//   nearly record       build the record for the current branch
+//   nearly post         put that record on the pull request
+//   nearly voices       list the narration voices you have
+//   nearly server       run the server in the foreground (it self-starts otherwise)
+//   nearly hook <ev>    internal: what the Claude Code hooks call
+//
+// Run it with no arguments inside a git repo and it does the useful thing,
+// because the useful thing is what people type first.
+
+import { spawn, spawnSync, execFileSync } from 'node:child_process';
+import { join, dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = resolve(join(dirname(fileURLToPath(import.meta.url)), '..'));
+const s = (n) => join(root, 'scripts', n);
+// Commands a person typed and is waiting on may mention an update. The hook
+// never does: nothing goes in front of an agent's tool call.
+const NOTIFY = new Set(['attach', 'on', 'init', 'record', 'recap', 'post', 'publish']);
+
+const run = async (file, args = []) => {
+  const r = spawnSync(process.execPath, [file, ...args], { stdio: 'inherit' });
+  if (NOTIFY.has(cmd) && (r.status ?? 0) === 0) {
+    try {
+      const { checkForUpdate, applyUpdate } = await import('../scripts/update-check.mjs');
+      applyUpdate(await checkForUpdate());
+    } catch { /* an update notice is never worth an error */ }
+  }
+  process.exit(r.status ?? 0);
+};
+
+const [cmd = 'attach', ...rest] = process.argv.slice(2);
+
+async function main() {
+switch (cmd) {
+  case 'attach': case 'on': case 'init':
+    return run(s('attach.mjs'), rest);
+
+  case 'off': case 'detach':
+    return run(s('attach.mjs'), [...rest, '--off']);
+
+  // Used by attach to confirm a `nearly` on PATH really is this tool before
+  // pointing hooks at a bare command name.
+  case '--which':
+    console.log(root);
+    return process.exit(0);
+
+  case 'hook':
+    return run(s('hook.mjs'), rest);
+
+  case 'record': case 'recap': {
+    // Default to the branch you are on, since that is what gets reviewed.
+    if (rest.length) return run(s('build-recap.mjs'), rest);
+    try {
+      const branch = execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { encoding: 'utf8' }).trim();
+      return run(s('build-recap.mjs'), ['--branch', branch, '--repo', process.cwd()]);
+    } catch { return run(s('build-recap.mjs'), ['latest']); }
+  }
+
+  case 'post':
+    return run(s('post-recap.mjs'), rest.length ? rest : ['latest']);
+
+  case 'publish':
+    return run(s('publish-pages.mjs'), rest);
+
+  case 'voices':
+    return run(s('build-recap.mjs'), ['--voices']);
+
+  case 'server': {
+    console.log('Nearly on http://127.0.0.1:47653');
+    console.log('You do not normally need this: the hooks start it when they need it.');
+    return run(join(root, 'server', 'index.mjs'), rest);
+  }
+
+  case 'open': {
+    const url = 'http://127.0.0.1:47653';
+    spawn(process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open',
+      [url], { stdio: 'ignore', detached: true, shell: process.platform === 'win32' }).unref();
+    console.log(url);
+    return process.exit(0);
+  }
+
+  case 'help': case '--help': case '-h': {
+    console.log(`
+  nearly              turn it on for the repo you are in
+  nearly off          turn it off again
+  nearly open         open the dashboard
+  nearly record       build the record for the current branch
+  nearly post         put that record on the pull request
+  nearly voices       list the narration voices you have
+  nearly server       run the server in the foreground
+`);
+    return process.exit(0);
+  }
+
+  default:
+    console.error(`Unknown command: ${cmd}`);
+    console.error('Try: nearly help');
+    process.exit(1);
+}
+}
+
+await main();

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "nearly-cli",
+  "version": "0.1.0",
+  "description": "A pull request tells you what changed. Nearly tells you what nearly happened: the commands a human refused, the pushes policy blocked, the turns rolled back.",
+  "type": "module",
+  "bin": {
+    "nearly": "bin/nearly.mjs"
+  },
+  "files": [
+    "bin",
+    "scripts",
+    "server",
+    "ui/index.html",
+    "ui/recap.template.html",
+    "README.md",
+    "STUDY.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {},
+  "keywords": [
+    "claude-code",
+    "coding-agent",
+    "code-review",
+    "pull-request",
+    "agent-supervision",
+    "hooks"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/anujpatel06/nearly.git"
+  },
+  "homepage": "https://anujpatel06.github.io/nearly/",
+  "scripts": {
+    "test": "node --test --test-concurrency=1 test/"
+  }
+}