jazz-ai 0.13.6 → 0.13.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/README.md +125 -248
  2. package/dist/main.js +485 -463
  3. package/package.json +5 -1
package/README.md CHANGED
@@ -4,14 +4,13 @@
4
4
 
5
5
  [![TypeScript](https://img.shields.io/badge/TypeScript-100%25-blue.svg)](https://www.typescriptlang.org/) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![npm version](https://img.shields.io/npm/v/jazz-ai.svg)](https://www.npmjs.com/package/jazz-ai)
6
6
 
7
- ### Your terminal. Your agent. Your rules.
7
+ ### One agent. Every surface. Your rules
8
8
 
9
- Jazz is an AI agent that lives in your terminal and actually does things.
10
- Not a chatbot. Not a wrapper around an API. A personal assistant you control,
11
- that reads your files, manages your git, searches the web, handles your email,
12
- and automates the workflows you're tired of doing by hand.
9
+ Jazz is an AI agent you install once and run everywhere: your terminal, a CI pipeline, a
10
+ cron schedule, a Telegram thread, a pull request. Same agent, same tools, same memory,
11
+ any model.
13
12
 
14
- [Quick Start](#quick-start) · [What Can It Do?](#what-can-it-do) · [Workflows](#workflows-automate-everything) · [CI/CD](#we-use-jazz-to-build-jazz) · [Docs](docs/README.md) · [Discord](https://discord.gg/yBDbS2NZju)
13
+ [Quick Start](#quick-start) · [Where It Runs](#where-jazz-runs) · [Reliability](#reliability) · [Workflows](#workflows) · [Docs](docs/index.md) · [Discord](https://discord.gg/yBDbS2NZju)
15
14
 
16
15
  </div>
17
16
 
@@ -19,335 +18,213 @@ and automates the workflows you're tired of doing by hand.
19
18
 
20
19
  ## Why Jazz?
21
20
 
22
- Because your terminal should be smarter than a blinking cursor.
21
+ A chatbot answers you. Jazz does the thing, wherever the work actually happens.
23
22
 
24
- Jazz is a personal assistant that lives where you already work. It can read your filesystem, manage your git repos, search the web, handle your email, run shell commands, talk to APIs -- and it does all of it autonomously, step by step, without you having to hold its hand. It's LLM provider agnostic, supports agent skills, and connects to anything through MCP.
23
+ - **Runs anywhere**: the same agent works in your terminal, in a script, on a schedule, on a pull request, or behind a chat bot.
24
+ - **Any model**: every major provider, swap mid-conversation, or run fully local with no API key.
25
+ - **Yours**: MIT-licensed, runs on your own machine or server, works offline, nothing leaves your disk.
26
+ - **Built for long jobs**: tracks its own progress, summarizes as it goes, delegates to helper agents, and tells you what it spent.
25
27
 
26
- Tell it to "analyze yesterday's unread emails and archive the newsletters" -- it connects to Gmail, reads your inbox, categorizes messages, and archives them. Tell it to "commit my changes with a good message" -- it runs `git diff`, reads the changes, writes a semantic commit message, and commits. Tell it to "find all security vulnerabilities in this codebase" -- it scans your files, analyzes patterns, and gives you a prioritized report.
27
-
28
- You describe what you want. Jazz figures out how to do it.
28
+ You describe the outcome. Jazz plans, calls tools, checks its own work, and reports back.
29
29
 
30
30
  ---
31
31
 
32
32
  ## Quick Start
33
33
 
34
34
  ```bash
35
- # Install
36
35
  npm install -g jazz-ai
37
- bun add -g jazz-ai
38
- pnpm add -g jazz-ai
39
- yarn global add jazz-ai
40
-
41
- # Start chatting
42
36
  jazz
43
37
  ```
44
38
 
45
- That's it. Jazz walks you through provider setup on first run.
39
+ Jazz walks you through provider setup on first run. Update anytime with `jazz update`.
46
40
 
47
- > **Start using Jazz for free** -- choose [OpenRouter](https://openrouter.ai) as your provider and select the [`Free Models Router`](https://openrouter.ai/openrouter/free). No credit card, no commitment.
41
+ Free option: [OpenRouter](https://openrouter.ai) with the
42
+ [`Free Models Router`](https://openrouter.ai/openrouter/free) model, no credit card. Private
43
+ option: `ollama`, fully local.
48
44
 
49
- Keep it updated:
50
-
51
- ```bash
52
- jazz update
45
+ ```text
46
+ > review the last 5 commits and flag anything risky
47
+ > check my unread email, summarize what matters, archive the rest
48
+ > deep-research the Three-Body Problem and write it into my Obsidian vault
49
+ > find every TODO in this repo, group by priority, and open an issue for the top 3
53
50
  ```
54
51
 
55
52
  ---
56
53
 
57
- ## What Can It Do?
58
-
59
- ### The short answer: almost anything you can describe.
60
-
61
- Jazz understands your filesystem, your git history, your shell, HTTP APIs, the web, PDFs and it can connect to external services through MCP. But capabilities are just the foundation. What makes Jazz different is how it _combines_ them to solve your actual problems.
54
+ ## Where Jazz runs
62
55
 
63
- ### Real examples, real workflows
56
+ Your agent isn't trapped in a terminal. `jazz run` is the one command behind every surface
57
+ below. It prints the answer and nothing else, so any script, bot, or CI job can call it.
58
+ Full contract: [Surfaces → Headless](docs/surfaces/headless.md).
64
59
 
65
- **Development**
60
+ | Surface | How you run it |
61
+ | --- | --- |
62
+ | Terminal | `jazz` |
63
+ | Scripts & pipes | `jazz run --json --agent dev "…"` |
64
+ | Cron / launchd | `jazz workflow schedule <name>` |
65
+ | GitHub PRs & Actions | [`.github/jazz/`](.github/jazz/), reviews every PR in this repo |
66
+ | Telegram | [`integrations/telegram-bot/`](integrations/telegram-bot/), `docker compose up` |
66
67
 
67
- ```
68
- > review the last 5 commits and flag anything that looks risky
69
- > find all TODO comments, group them by priority, and create a summary
70
- > refactor this function to use async/await and update all callers
71
- > generate a PR description from the current branch diff
72
- ```
68
+ Want Slack, Google Chat, or Discord instead? The same `jazz run` contract works there too, as
69
+ a bridge you write yourself (~100 lines). See [Chat platforms](docs/surfaces/chat-platforms.md).
73
70
 
74
- **Email & Communication**
71
+ ---
75
72
 
76
- ```
77
- > check my unread emails, summarize anything important, archive the rest
78
- > draft a reply to the latest email from Sarah about the project timeline
79
- ```
73
+ ## Model providers
80
74
 
81
- **Research & Analysis**
75
+ Every major LLM provider, plus `ollama` and `llama.cpp` for running models locally with no
76
+ API key. Switch with `/model` mid-conversation, or point different agents at different
77
+ providers. Full list: [Providers](docs/integrations/providers.md).
82
78
 
83
- ```
84
- > research the latest developments in WebAssembly and write a 2-page summary
85
- > compare React Server Components vs Astro islands architecture with pros and cons
86
- > analyze this PDF report and extract the key financial metrics
87
- ```
79
+ Fully airgapped mode is supported: `JAZZ_OFFLINE=1` stops all outbound requests except
80
+ inference itself. See [Airgapped & Self-Hosted](docs/guide/airgapped.md).
88
81
 
89
- **Knowledge Management**
82
+ ---
90
83
 
91
- ```
92
- > do deep research on the Three-Body Problem and write it in my Obsidian vault
93
- ```
84
+ ## Reliability
94
85
 
95
- ### LLM Provider Agnostic
86
+ Most agent tools fall apart on tasks longer than a couple of minutes. Jazz is built for
87
+ tasks that take a while:
96
88
 
97
- Jazz doesn't lock you in. Use whichever model fits the task or switch mid-conversation. Run locally with Ollama, go through OpenRouter for access to hundreds of models, or plug in your own endpoint.
89
+ - **Budgeted iterations** that warn themselves to wrap up as they approach the limit.
90
+ - **Loop detection** that catches an agent repeating itself and forces a different approach.
91
+ - **Automatic context compaction** that summarizes and continues instead of truncating or crashing.
92
+ - **Sub-agents** for delegating research or coding work without blowing the parent's context.
93
+ - **Cost tracking** on every run, with a daily spend cap for unattended use.
98
94
 
99
- OpenAI, Anthropic, Google, Mistral, xAI, DeepSeek, Groq, Cerebras, Fireworks, TogetherAI, Ollama, llama.cpp, OpenRouter, and more.
95
+ Built on TypeScript and [Effect-TS](https://effect.website/), so failures have a typed
96
+ recovery path instead of crashing silently. Details:
97
+ [Agent loop](docs/internals/agent-loop.md) ·
98
+ [Design decisions](docs/internals/design-decisions.md).
100
99
 
101
- ### MCP: Connect to Everything
100
+ ---
102
101
 
103
- Jazz speaks [Model Context Protocol](https://modelcontextprotocol.io/). One config block, and your agent can talk to any MCP-compatible service:
102
+ ## Tools & integrations
104
103
 
105
- Simply run `jazz mcp add` and input the MCP configuration:
104
+ **43 built-in tools**: files, git, shell, web search and fetch, HTTP, todos, sub-agents.
105
+ Each has a documented risk level. See [Tools reference](docs/reference/tools.md).
106
106
 
107
- ```json
108
- {
109
- "mcpServers": {
110
- "notion": {
111
- "command": "npx",
112
- "args": ["-y", "mcp-remote", "https://mcp.notion.com/mcp"]
113
- },
114
- "github": {
115
- "command": "npx",
116
- "args": ["-y", "@modelcontextprotocol/server-github"]
117
- }
118
- }
119
- }
120
- ```
107
+ **Skills** are playbooks the agent loads on demand: deep research, code review, meeting
108
+ notes, commit conventions. 18+ ship built in, and Jazz follows the
109
+ [`.agents` convention](https://agentskills.io), so anything from the ecosystem works. Add
110
+ your own to `~/.jazz/skills/` or `./skills/`, or run `npx skills add`.
121
111
 
122
- ### Skills: Extend Your Agent
112
+ **Personas** control tone and style independently of the model: `default`, `coder`,
113
+ `researcher`, or your own with `jazz persona create`.
123
114
 
124
- Skills are packaged expertise your agent loads on demand—proven playbooks for complex tasks instead of winging it every time. Think deep research with multi-source verification, structured code review, meeting notes that follow your format, PR descriptions from your conventions. You get consistency and domain expertise without stuffing the context window.
115
+ **Custom tools** let you add a capability with no code: a name, a schema, and a shell
116
+ command or HTTP call in the agent's config. See
117
+ [Configuration](docs/reference/configuration.md#agent-config-customtools).
125
118
 
126
- Jazz ships with **15+ built-in skills**—deep research, email, calendar, browser automation, Obsidian, and more. Add your own from the ecosystem: Jazz follows the [`.agents` convention](https://agentskills.io), so any skill works. Run `npx skills add` to browse and install, or drop a skill in `~/.jazz/skills/` (global) or `./skills/` (project-local). Use `/skills` in chat to browse what's available.
119
+ **MCP** connects Jazz to anything else. `jazz mcp add`, paste a server config, and its
120
+ tools are available to any agent that requests them.
127
121
 
128
122
  ---
129
123
 
130
- ## Workflows: Automate Everything
131
-
132
- A workflow is a Markdown file that describes what your agent should do, when it should do it, and how much autonomy it gets. Schedule them with cron, run them headless, and let Jazz handle the boring parts of your day.
133
-
134
- ### Built-in Workflows
124
+ ## Workflows
135
125
 
136
- Jazz ships with workflows ready to go:
137
-
138
- | Workflow | Schedule | What it does |
139
- | -------------------- | ------------- | ----------------------------------------------------------------- |
140
- | **email-cleanup** | Hourly | Archive newsletters, organize promotions, flag important messages |
141
- | **weather-briefing** | Every morning | Weather forecast + outfit recommendations for your location |
142
- | **market-analysis** | Daily | Stock/crypto analysis with buy/sell signals |
143
-
144
- ### Create Your Own
145
-
146
- Any task you do repeatedly can become a workflow. Write a `WORKFLOW.md`:
126
+ A workflow is a Markdown file that says what to do, when, and how much autonomy it gets.
147
127
 
148
128
  ```yaml
149
129
  ---
150
130
  name: daily-standup-prep
151
- description: Prepare my daily standup notes
152
- schedule: "0 9 * * 1-5" # 9 AM, weekdays
153
- agent: my-dev-agent
131
+ schedule: "0 9 * * 1-5" # weekdays, 9am
154
132
  autoApprove: read-only
155
133
  ---
134
+ Check my git activity from yesterday and summarize what I worked on as bullet points.
156
135
  ```
157
136
 
158
- ```markdown
159
- Check my git activity from yesterday across all repos in ~/projects/.
160
- Summarize what I worked on, what PRs I opened or reviewed,
161
- and any blockers I mentioned in commit messages.
162
- Format it as bullet points I can paste into Slack.
163
- ```
164
-
165
- Then schedule it:
166
-
167
137
  ```bash
168
138
  jazz workflow schedule daily-standup-prep
169
139
  ```
170
140
 
171
- Jazz uses `launchd` on macOS and `cron` on Linux. If your machine was asleep when a workflow was supposed to run, Jazz can catch up automatically on next launch.
172
-
173
- ### Auto-Approve Policies
174
-
175
- Control how much autonomy each workflow gets:
176
-
177
- | Policy | What it auto-approves |
178
- | ----------- | ------------------------------------------- |
179
- | `false` | Nothing -- always asks |
180
- | `read-only` | Reading files, searching, web requests |
181
- | `low-risk` | + archiving email, creating calendar events |
182
- | `high-risk` | + file changes, shell commands, git push |
141
+ Jazz schedules through `launchd` on macOS and `cron` on Linux, and can catch up runs your
142
+ laptop slept through. Three workflows ship built in; the
143
+ [Cookbook](docs/cookbook/index.md) has seven more ready to copy.
183
144
 
184
145
  ---
185
146
 
186
- ## We use Jazz to build Jazz.
187
-
188
- Jazz isn't just a local tool. It runs in CI/CD pipelines with `--output raw` and `--auto-approve` flags, purpose-built for automation.
189
-
190
- ### Automated Code Review
191
-
192
- Every pull request to Jazz gets reviewed by a Jazz agent. The [`jazz.yml`](.github/workflows/jazz.yml) workflow:
193
-
194
- 1. Installs `jazz-ai` in the CI runner
195
- 2. Runs a code review workflow against the PR diff
196
- 3. Posts **inline review comments** directly on the PR -- on specific lines, with context
197
-
198
- ```yaml
199
- # .github/workflows/jazz.yml (simplified)
200
- - name: Run Jazz code review
201
- run: jazz --output raw workflow run code-review --auto-approve --agent ci-reviewer
202
- env:
203
- OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
204
- ```
205
-
206
- Comment `/jazz-review` on a pull request to trigger a review on demand, or `/jazz <request>` to ask the PR assistant anything.
207
- The review agent checks for correctness, security issues, TypeScript best practices, Effect-TS patterns, and performance concerns. Real reviews, on real code, every PR.
208
-
209
- ### Automated Release Notes
210
-
211
- Every release gets its notes written by Jazz. The [`release.yml`](.github/workflows/release.yml) workflow:
212
-
213
- 1. Bumps the version and creates a git tag
214
- 2. Runs a Jazz agent to analyze all commits since the last release
215
- 3. Generates release notes grouped by feature area
216
- 4. Creates the GitHub Release with those notes
217
-
218
- No more "what changed in this release?" -- Jazz reads the commits, understands the changes, and writes release notes that actually make sense.
147
+ ## We use Jazz to build Jazz
219
148
 
220
- ### Run Jazz in Your Own Pipelines
149
+ Every pull request to this repo is reviewed by a Jazz agent, which posts inline comments on
150
+ the diff. Comment `/jazz-review` to re-run it, or `/jazz <question>` to ask about the PR.
151
+ Release notes are drafted the same way, from the commits since the last tag.
221
152
 
222
- ```yaml
223
- # Your .github/workflows/review.yml
224
- name: AI Code Review
225
- on: pull_request
226
-
227
- jobs:
228
- review:
229
- runs-on: ubuntu-latest
230
- steps:
231
- - uses: actions/checkout@v4
232
- with:
233
- fetch-depth: 0
234
-
235
- - run: npm install -g jazz-ai
236
-
237
- - name: Run review
238
- run: jazz --output raw workflow run my-review --auto-approve
239
- env:
240
- OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
241
- ```
242
-
243
- See [`.github/jazz/`](.github/jazz/) for the full agent configs and workflow templates we use.
153
+ Copy [`.github/jazz/`](.github/jazz/) and [`jazz.yml`](.github/workflows/jazz.yml) into your
154
+ own repo and add one provider secret to get the same setup. Guide:
155
+ [`.github/jazz/README.md`](.github/jazz/README.md).
244
156
 
245
157
  ---
246
158
 
247
- ## You Stay in Control
248
-
249
- Jazz is powerful, but it never acts without your say-so.
159
+ ## Safety & permissions
250
160
 
251
- **Requires approval:** File changes, git commits, shell commands, sending emails, API mutations
252
- **Runs freely:** Reading files, searching, analyzing code, web lookups, viewing data
161
+ Nothing runs without a say-so. One dial controls what's allowed to run unattended, for the
162
+ terminal, CI, and any bot the same way:
253
163
 
254
- Every action is logged. You see exactly what Jazz wants to do before it does it. You can review, approve, deny, or modify. Full audit trail, always.
164
+ | Policy | Auto-approves |
165
+ | --- | --- |
166
+ | `false` | Nothing, always asks |
167
+ | `read-only` | Reading files, search, web requests |
168
+ | `low-risk` | + todo tracking, spawning sub-agents |
169
+ | `high-risk` | + file changes, shell commands, git commit and push |
255
170
 
256
- Credentials are stored securely (OAuth2 for Gmail, API keys in config). Nothing is logged or exposed.
171
+ Every gated action is proposed before it executes, so you see exactly what will happen
172
+ before it happens. Details: [Tools & approval](docs/internals/tools-and-approval.md).
173
+ Reporting a vulnerability: [SECURITY.md](SECURITY.md).
257
174
 
258
175
  ---
259
176
 
260
- ## Command Reference
261
-
262
- **Agents**
263
-
264
- | Command | Description |
265
- | ----------------------------- | -------------------------- |
266
- | `jazz` | Start chatting |
267
- | `jazz agent create` | Create a new agent |
268
- | `jazz agent list` | List all agents |
269
- | `jazz agent show <id>` | Show agent details |
270
- | `jazz agent edit <id>` | Edit an agent |
271
- | `jazz agent delete <id>` | Delete an agent |
272
- | `jazz agent chat <name>` | Chat with a specific agent |
273
-
274
- **Workflows**
275
-
276
- | Command | Description |
277
- | --------------------------------- | ------------------------------ |
278
- | `jazz workflow list` | List available workflows |
279
- | `jazz workflow show <name>` | Show workflow details |
280
- | `jazz workflow run <name>` | Run a workflow |
281
- | `jazz workflow schedule <name>` | Schedule a workflow |
282
- | `jazz workflow unschedule <name>` | Remove a workflow schedule |
283
- | `jazz workflow scheduled` | List scheduled workflows |
284
- | `jazz workflow catchup` | Run missed scheduled workflows |
285
- | `jazz workflow history [name]` | View workflow run history |
286
-
287
- **MCP, Personas & Config**
288
-
289
- | Command | Description |
290
- | -------------------------- | ---------------------- |
291
- | `jazz mcp add` | Add an MCP server |
292
- | `jazz mcp list` | List MCP servers |
293
- | `jazz mcp remove` | Remove an MCP server |
294
- | `jazz mcp enable` | Enable an MCP server |
295
- | `jazz mcp disable` | Disable an MCP server |
296
- | `jazz persona create` | Create a persona |
297
- | `jazz persona list` | List personas |
298
- | `jazz persona show <id>` | Show persona details |
299
- | `jazz persona edit <id>` | Edit a persona |
300
- | `jazz persona delete <id>` | Delete a persona |
301
- | `jazz config show` | View configuration |
302
- | `jazz config get <key>` | Get a config value |
303
- | `jazz config set <key>` | Set a config value |
304
- | `jazz update` | Update to latest version |
305
-
306
- **In-chat commands:** `/tools`, `/skills`, `/model`, `/mode`, `/cost`, `/context`, `/compact`, `/switch`, `/workflows`, and more. Type `/help` during chat.
177
+ ## Command reference
307
178
 
308
- ---
179
+ ```bash
180
+ jazz # start chatting
181
+ jazz run --agent <a> "<prompt>" # one-shot, headless
182
+ jazz agent create|list|show|edit|delete|chat
183
+ jazz workflow list|show|run|schedule|unschedule|scheduled|catchup|history
184
+ jazz mcp add|list|remove|enable|disable
185
+ jazz persona create|list|show|edit|delete
186
+ jazz config show|get|set
187
+ jazz update
188
+ ```
309
189
 
310
- ## Built to Be Reliable
190
+ In chat: `/tools` `/skills` `/model` `/mode` `/cost` `/context` `/compact` `/switch`
191
+ `/workflows`, or `/help`. Full reference: [CLI](docs/reference/cli.md).
311
192
 
312
- Jazz is 100% TypeScript with [Effect-TS](https://effect.website/) under the hood. That means every error has a recovery path, every side effect is tracked, and nothing silently fails.
193
+ ---
313
194
 
314
- It manages its own context window (auto-summarizes when things get long), delegates deep tasks to sub-agents, and gracefully recovers from timeouts and failures. You can throw complex, multi-step problems at it and trust that it won't fall apart halfway through.
195
+ ## Documentation
315
196
 
316
- ---
197
+ Start at **[`docs/index.md`](docs/index.md)**.
317
198
 
318
- ## Documentation & Community
199
+ | Topic | Links |
200
+ | --- | --- |
201
+ | Getting started | [Quick Start](docs/guide/quick-start.md) · [Creating Agents](docs/guide/creating-agents.md) |
202
+ | Where it runs | [Surfaces](docs/surfaces/index.md) · [Headless](docs/surfaces/headless.md) · [Chat platforms](docs/surfaces/chat-platforms.md) · [CI/CD](docs/surfaces/ci-cd.md) · [Scheduled](docs/surfaces/scheduled.md) |
203
+ | Examples | [Use Cases](docs/guide/index.md#end-to-end-use-cases) · [Cookbook](docs/cookbook/index.md) · [Examples](examples/) |
204
+ | Concepts | [Agents](docs/concepts/agents.md) · [Personas](docs/concepts/personas.md) · [Skills](docs/concepts/skills.md) · [Tools](docs/concepts/tools.md) · [Workflows](docs/concepts/workflows.md) |
205
+ | Self-hosting | [Airgapped](docs/guide/airgapped.md) · [Telegram bridge](integrations/telegram-bot/) |
206
+ | Reference | [CLI](docs/reference/cli.md) · [Configuration](docs/reference/configuration.md) · [Tools](docs/reference/tools.md) |
207
+ | Internals | [Agent loop](docs/internals/agent-loop.md) · [Context management](docs/internals/context-management.md) · [Design decisions](docs/internals/design-decisions.md) |
319
208
 
320
- | | |
321
- | ---------------------- | ---------------------------------------------------------------- |
322
- | **Full Documentation** | [`docs/README.md`](docs/README.md) |
323
- | **Tools Reference** | [`docs/tools-reference.md`](docs/tools-reference.md) |
324
- | **Integrations** | [`docs/integrations.md`](docs/integrations.md) |
325
- | **Examples** (20+) | [`examples/`](examples/) |
326
- | **Research & Roadmap** | [`docs/exploration/`](docs/exploration/) |
327
- | **Discord** | [Join the community](https://discord.gg/yBDbS2NZju) |
328
- | **Discussions** | [GitHub Discussions](https://github.com/lvndry/jazz/discussions) |
329
- | **Issues** | [Report a bug](https://github.com/lvndry/jazz/issues) |
209
+ **Community:** [Discord](https://discord.gg/yBDbS2NZju) ·
210
+ [Discussions](https://github.com/lvndry/jazz/discussions) ·
211
+ [Issues](https://github.com/lvndry/jazz/issues)
330
212
 
331
213
  ---
332
214
 
333
215
  ## Contributing
334
216
 
335
- We welcome contributions -- bug fixes, docs, tests, features, and ideas.
336
-
337
- See [`CONTRIBUTING.md`](CONTRIBUTING.md) for the contributor guide.
338
-
339
- ---
217
+ Bug fixes, docs, tests, features, and ideas all welcome. See
218
+ [`CONTRIBUTING.md`](CONTRIBUTING.md).
340
219
 
341
220
  ## License
342
221
 
343
- MIT -- see [`LICENSE`](LICENSE).
222
+ MIT. See [`LICENSE`](LICENSE).
344
223
 
345
224
  ---
346
225
 
347
226
  <div align="center">
348
227
 
349
- **The sky is the limit.** Start automating.
350
-
351
228
  ```bash
352
229
  npm install -g jazz-ai && jazz
353
230
  ```