40 New Commits. Zero Motivation to Read Them.

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady.

What I Built

You take a few days off. Come back, pull the latest changes, and suddenly there are 40 new commits.

Great. Now you have to figure out what everyone did before you can even start working.

Sure, there's git log, git diff, and a bunch of other commands to help. But reading through commits, figuring out which changes belong together, and checking if anything important broke isn't exactly how I want to spend my morning.

So I built RepoSloth, an open-source AI-powered CLI that helps developers catch up on their repositories without digging through every commit.

It reads your Git history, groups related changes, explains what happened, and highlights things you might want to review.

Think of it as a quick briefing from a teammate who actually read all the commits.

Except this one runs locally and doesn't need an API key.

Here's what it can do:

• Catch up on recent changes. Get a summary of what happened over the last few days or weeks.
• Group related commits. See changes organized by workstream instead of reading a long chronological list.
• Spot potential risks. Get a heads-up about migrations, dependency updates, and configuration changes.
• Ask questions. Want to know if someone touched authentication? Just ask.
• Go full sloth mode. Use --lazy when you only want the important stuff.

Every finding includes references to actual commits and files, so you can verify what the AI tells you.

It's not trying to replace code review. It's just helping you figure out where to start.

Demo

The default command summarizes the last three days:

reposloth

Want to check the past week?

reposloth --since 7d

Don't feel like reading a long report?

reposloth --lazy

Coming back from vacation?

reposloth vacation --since 14d --checklist

This gives you a catch-up report with a checklist of changes worth reviewing.

You can also ask questions about the repository history:

reposloth ask --since 7d

For example:

Did anyone change the authentication logic?

RepoSloth searches the selected history and explains the relevant changes, including which commits and files to check.

Reports can also be exported as Markdown or JSON.

Code

GitHub: memar1992/reposloth

The project is MIT licensed and currently installs from source.

The README includes installation instructions, model setup, available commands, and known limitations.

Contributions are welcome. It's still a relatively small project, and there's plenty of room to improve it.

How I Built It

RepoSloth is written in TypeScript and uses a fully local AI setup.

Here's the stack:

• Qwen2.5 Coder 1.5B as the default open-weight LLM.
• Ollama for local inference.
• Mastra for the agent and workflow orchestration.
• Git CLI for collecting commits, changed files, and diffs.
• Zod for validating structured AI responses.

I chose a small model intentionally. I wanted something developers could run locally without needing expensive hardware or a paid API.

Of course, smaller models come with trade-offs, especially when analyzing a large amount of code.

So instead of sending the entire Git history to the LLM and hoping for the best, I built a workflow around it.

How the workflow works

RepoSloth uses a five-step Mastra workflow:

1. Collect history. Read commits, changed paths, line counts, and bounded diffs from the local repository.
2. Group changes. Organize related files into workstreams so the model has more useful context.
3. Analyze with Qwen. Generate explanations based on the collected Git evidence.
4. Identify potential risks. Flag changes involving migrations, dependencies, and configuration that may need review.
5. Validate and format. Check the references, apply the selected report mode, and cache the result locally.

You can inspect the actual workflow implementation here.

Mastra handles the orchestration, while Qwen runs through Ollama using ollama-ai-provider-v2.

For larger repositories, the input is split into bounded chunks, analyzed separately, and then combined into a final briefing.

Making a small local model useful

One thing I didn't want was an AI confidently reporting changes that never happened.

The generated output goes through schema validation, and RepoSloth checks whether referenced files actually belong to the commits being cited.

That doesn't guarantee the explanation is always correct, but at least the references point to real changes.

Potential risks are also treated as things worth investigating, not confirmed bugs.

If Ollama isn't running or the AI response isn't usable, RepoSloth falls back to a deterministic Git summary.

There's also a --no-ai option if you want to skip inference entirely.

And since the tool reads repository history, I added some boundaries. It doesn't modify repository files or switch branches, filters common sensitive paths and known secret patterns, and restricts inference requests to local addresses. The Mastra agent itself has no tools.

I wanted RepoSloth to be useful without giving an AI agent unnecessary access to the project.

Why Does Open Innovation Matter?

One of the reasons I started this project was that I didn't want another developer tool that required an API key just to do something relatively simple.

Git history can contain internal code, business logic, and implementation details. Sending all of that to a hosted AI service isn't always an option.

With Qwen running through Ollama, RepoSloth can analyze that history on your own machine.

No paid AI API. No cloud inference account. No GitHub integration required.

It even works on local repositories without a remote.

Using an open-weight model also means you're not locked into the default one. RepoSloth uses Qwen2.5 Coder 1.5B, but you can switch to another locally installed model using --model.

And because the project itself is open source, developers can inspect how Git data is collected, how the prompts work, and how the output is validated.

Mastra and Ollama made it practical for me to build this without having to implement local inference or agent orchestration from scratch.

That's what I like about open-source tooling. You can take existing pieces, build something useful, and let other people improve it.

The Lazy Payoff

The biggest time sink when returning to a repository isn't necessarily reading code.

It's figuring out which code you should be reading in the first place.

Normally, I'd start with git log, open a few commits, inspect the diffs, jump between files, and slowly piece together what happened.

And sometimes, after doing all that, I'd realize half the commits weren't even relevant to what I was working on.

With RepoSloth, I can run:

reposloth --since 7d

And get a starting point.

If something looks important, I can inspect the referenced commits. If I only care about a specific feature, I can ask about it. If I just need the highlights, there's --lazy.

I'm not going to claim it saves exactly 30 minutes or makes developers 10x more productive. I haven't benchmarked that.

What it does is remove a lot of the manual scanning involved in catching up.

You still need to review code, understand the changes, and make your own decisions. RepoSloth just handles some of the boring work before that.

And that's really the idea behind the project.

I don't want AI writing every line of code for me.

Sometimes I just want it to read the commits I don't feel like reading. 😂

Prize Categories

Best Use of Mastra

RepoSloth uses a five-step Mastra workflow to collect, group, analyze, validate, and summarize Git history. A Mastra agent powered by local Qwen inference handles the AI briefings and follow-up questions.