DEV Community: Abdulaleem Zakariyah

Sloth Nap: two lines in the morning, instead of the chores you keep skipping

Abdulaleem Zakariyah — Thu, 22 Oct 2026 20:54:59 +0000

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

What I Built

Sloth Nap is for the evening you do not want to deal with the pile. You drop a chore table and a couple of notes into a folder. It ranks which tasks you are likely to skip again, finds the one sentence in the notes that actually has a date, looks up the question you were avoiding, and leaves two lines for the morning.

On the sample pile, those lines are the receipts and a one-sentence reply to the landlord. Together they are about 55 minutes. The plants, the dentist, and the downloads folder can wait. Nothing is deleted. Copying the notes into an archive folder stays pending until a person approves it, and a second approval does not copy them again.

The person who gets to be lazier is whoever keeps reopening the same three tasks and the same lease PDF. The nap does that pass once.

Demo

Do file the receipts and reply to the landlord. Those are the chores you keep skipping.

The only sentence that matters: the lease renewal notice is due on November 2. Leave sort the downloads folder and book the dentist for later. Filing online is $30. Showing up in person is $45 and a morning.

npm install
npm test
npm run nap

out/morning-brief.md is the result. npm run nap -- --approve copies the notes once. npm start serves those two lines on port 3000.

Code

MIT, on GitHub: zakkycrypt01/sloth-nap

zakkycrypt01 / sloth-nap

Sloth Nap

An overnight chore agent for the Hacktoberfest Week 3 challenge. You drop the tasks you keep avoiding into inbox/. It ranks what you will skip, pulls the one date buried in the notes, looks up the question you did not want to search, and leaves two lines in out/morning-brief.md.

On the sample inbox that is the receipts and the landlord reply: about 55 minutes. Archiving the notes waits until you approve it.

Run it

npm install
npm test
npm run nap

npm start serves the brief at http://localhost:3000. Add --approve to copy the notes into out/archived. Add --slow if you want a pause between steps.

The sample run does not call a hosted model. If Ollama is running with gemma2:2b, the two lines come from Gemma. Otherwise a template writes them from the same facts, and the brief says model: template.

…

View on GitHub

The project is a new repo started during this challenge window. The commit on master is ddc4f5e.

inbox/                  sample chores, lease note, question
src/mastra/             Mastra agent, forecast tool, LibSQL memory
src/nap/                brief, approval ledger, pile search, partner clients
src/temporal/           durable nap: activities, then a signal wait
python/tabpfn_forecast.py
python/tinker_eval.py
arduino/sloth_nap/      UNO Q sketch
render.yaml
deploy/digitalocean-app.yaml
.github/workflows/overnight-nap.yml

The archive path is the one I want a judge to look at. The intent is written as submitted before the copy, then confirmed after. A retry that finds confirmed returns without copying. A retry that finds submitted (the copy timed out) does not guess.

How I Built It

The open piece at the center is Mastra, an open-source TypeScript agent harness. The agent is sloth-nap. Its tool, forecast-skips, fits a small logistic model on age, minutes, dread, and how many of the last four attempts were skipped. Memory is LibSQL. GDS K S's Mastra walkthrough is the shape I used: an agent, a Zod tool, and memory.

Gemma writes the two lines. The client posts to Ollama /api/chat with gemma2:2b.

Two other posts decided the approval design. Takashi Obara's Temporal write-up is why the archive is a signal wait in src/temporal/workflows.ts rather than a poll. The retry essay is why the idempotency key is stored before the copy. A commenter on that essay, Abhinav Sharma, points out that a key does nothing if the far side ignores it. Here the far side is this process, so the ledger is the far side.

The workflow runs the nap, then waits on the approval signal. python/tinker_eval.py trains the same kind of classifier: 0.85 on the holdout against a majority-class baseline of 0.80. python/tabpfn_forecast.py is the TabPFN path for that same ranking.

Why Does Open Innovation Matter?

The notes in this project are a lease date and a dread score. The ranker and Gemma run on the machine, so the pile stays in the folder. Swapping the model is a name, not a new vendor. Mastra keeps the tool and the memory in an open harness.

The Lazy Payoff

Chore	Minutes	What the nap did
File the receipts	40	Do this
Reply to the landlord	15	Do this, before November 2
Sort the downloads folder	25	Leave it
Book the dentist	10	Leave it
Water the plants	5	Leave it
Renew the library card	8	Leave it

About 55 minutes of the chores the model thinks you will skip. The other 48 minutes are the ones you already do. Filing the small claim online is $30. Showing up in person is $45 and a morning.

Prize Categories

Best Use of Mastra. The forecast tool, the agent, and LibSQL memory are what rank the chores. The tests construct the agent and the nap calls the tool.

Wow

Abdulaleem Zakariyah — Sun, 04 Oct 2026 17:50:20 +0000

Hacktoberfest Weekend Challenge: Build for a Friend Submission 🤝

Usman Abdullahi Olukayode

Oct 4

FixIt AI: An Open-Weight Technical Troubleshooting Friend Powered by Google Gemma

#hf26challenge #ai #gemma #render

3 min read

PyReviewer: A Production-Grade Python AST, Security & Docker Reviewer for Large Codebases

Abdulaleem Zakariyah — Sun, 04 Oct 2026 17:00:46 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

I built PyReviewer for my close friend Dave, a self-taught junior Python developer currently building multi-file FastAPI microservices and background data pipelines.

Who I Built It For: My Friend Dave

Dave is a passionate developer, but like many juniors working across growing multi-file repositories, he continually runs into high-severity traps that are hard to catch without senior peer review:

Async Concurrency Freezes: Accidentally placing synchronous blocking functions (time.sleep(), requests.get()) inside FastAPI async def endpoints, locking Python's single-threaded event loop and stalling client requests.
Mutable Default Leaks: Using def append_item(item, cache=[]), causing memory to leak and state to bleed across completely unrelated requests.
OWASP Security Vulnerabilities: String-interpolated SQL queries (f"SELECT * FROM users WHERE id = '{user_id}'"), shell command injections (subprocess.run(..., shell=True)), and insecure deserialization (pickle.loads()).
Codebase Review Fatigue: Struggling to get a unified view of 30+ files across a repo, rank security hotspots, and write production-hardened Dockerfiles that don't run as root.

What PyReviewer Does For Him

PyReviewer turns large, messy codebases into clean, production-ready systems in seconds:

GitHub Repository Scanner: Dave pastes his public GitHub repository URL. PyReviewer executes a shallow clone, indexes every Python file into an interactive 3-column file tree explorer, and runs an AST security sweep.
Deterministic AST & Security Engine: Inspects Python Abstract Syntax Trees via ast.NodeVisitor for zero-day vulnerabilities, blocking async calls, and Python anti-patterns.
Hotspot Ranking & Executive Audit Report: Ranks files by risk concentration and compiles a comprehensive, downloadable Markdown audit report.
Unified Refactor Diffs: Generates Git-style unified diffs showing exact fixes with a 1-click "Apply Refactor" button.
Production Docker Packaging & Render Deployment: Automatically generates a hardened multi-stage Dockerfile and a render.yaml Blueprint for 1-click deployment on Render.

Demo

PyReviewer is containerized with Docker and running live in production on Render:

🌐 Live Web Application: https://pyreviewer.onrender.com/
🩺 Production Healthcheck: https://pyreviewer.onrender.com/healthz

How It Works:

Paste any GitHub repository URL (e.g. https://github.com/psf/requests or click "Load Demo Microservice Repo").
The 3-column workspace immediately opens the codebase tree, color-coded by vulnerability risk (Green = Safe, Amber = Warnings, Red = Critical Flaws).
Select any file to inspect syntax-highlighted code with gutter line numbers and live diagnostic warning pills.
Click "Review & Refactor" to inspect unified diffs and one-click fixes.
Switch to "Docker & Render" to inspect the auto-generated multi-stage Dockerfile and one-click deploy to Render.

Code

PyReviewer is completely open source under the MIT License:

├── Dockerfile                  # Hardened Docker container for Render (git + non-root user)
├── render.yaml                 # Render Blueprint specification
├── docker-compose.yml          # Local container orchestration
├── server.py                   # High-performance server with /healthz & /api/scan-repo
├── requirements.txt            # Optional production dependencies
├── .dockerignore               # Clean container exclusion rules
├── app/
│   ├── analyzer.py             # Pure Python AST NodeVisitor & Security Rules
│   └── repo_scanner.py         # Git shallow cloning & repository auditor
└── static/
    ├── index.html              # Clean 3-column repository explorer UI
    ├── style.css               # Slate/zinc high-density developer stylesheet
    └── app.js                  # File tree, diff viewer & report exporter

How I Built It

PyReviewer is built around an open agentic harness and open-source local analysis tools:

Open-Source Agent Harness: Developed collaboratively using the open Antigravity agentic harness with the DevRelay gateway, which tracked session milestones and verified architectural decisions.
Deterministic AST Visitor Engine (ast.NodeVisitor): Rather than relying on unreliable black-box LLMs that hallucinate syntax errors or leak source code, PyReviewer inspects the raw compiler syntax tree using Python's native ast library:

   class PythonASTAnalyzer(ast.NodeVisitor):
       def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef):
           for child in ast.walk(node):
               if isinstance(child, ast.Call):
                   name = self._get_call_name(child.func)
                   if name in ["time.sleep", "sleep"]:
                       self.issues.append({
                           "line": child.lineno,
                           "code": "PERF-001",
                           "title": "Blocking Call in Async Function",
                           "severity": "CRITICAL",
                           "message": f"Synchronous '{name}()' blocks the event loop in '{node.name}'.",
                           "suggestion": "Use 'await asyncio.sleep()' instead."
                       })

Multi-Stage Docker Packaging: Packaged inside a slim python:3.12-slim container with git and ca-certificates installed so repository cloning works directly inside the container, running under non-root appuser (UID 10001).
Render Infrastructure-as-Code (render.yaml): Uses a declarative Render Blueprint to configure the container web service, health checks, and port forwarding.

Why Does Open Innovation Matter?

Zero Intellectual Property & Code Leakage: Dave and other developers should never have to paste proprietary codebases into closed third-party cloud LLMs where sensitive code can be retained or used for model retraining. PyReviewer runs AST analysis entirely locally on Dave's laptop or inside his own isolated Render container.
100% Deterministic & Reproducible: Closed AI models yield stochastic, inconsistent outputs between runs. Python's native AST engine produces identical, reproducible results every time, making it suitable for CI/CD gating and production standards.
Zero Inference Costs & Zero Latency: No expensive API keys, no rate limits, and sub-20ms analysis times across dozens of files.

My Agent Session

The complete end-to-end development session was captured and curated using DevRelay:

PyReviewer: Large Codebase GitHub Scanner & Executive Audit Reporter for Render

You

Make it suitable for large codebase where the user can just paste in the GitHub URL, it populates the codebase, and scans and writes a detailed report.

Agent

We expanded PyReviewer into a full repository-scale code auditor. We added a shallow git cloning engine with ast.NodeVisitor traversal that maps entire GitHub codebases into an interactive file tree, ranks risk hotspots, and generates an audit-grade Markdown report with multi-stage Dockerfile and render.yaml blueprints.

▸ scan_repository https://github.com/bottlepy/bottle

Input

https://github.com/bottlepy/bottle

Output

Scanned 30 files, 7,492 LOC in under 5 seconds with zero cloud leakage.

(View the complete transcript on DevRelay Agent Session #470.)

Prize Categories

Best Use of Render ($200 Featured Category): PyReviewer is deployed in production as a Docker web service on Render at https://pyreviewer.onrender.com/. It features native /healthz health check monitoring, a production Dockerfile with non-root security isolation, and a declarative render.yaml Blueprint for 1-click zero-downtime deployment.