DEV Community: Aliza Ali

NotionOps AI — 4 AI Agents That Run Your Dev Workflow End-to-End

Aliza Ali — Fri, 13 Mar 2026 14:35:46 +0000

This is a submission for the Notion MCP Challenge

What I Built

NotionOps AI is an autonomous workflow engine that connects GitHub, OpenAI, and Notion into a single pipeline for software development teams.

It runs 4 specialized AI agents that automate the daily dev lifecycle:

Agent	What it does
Issue Triage	Fetches open GitHub issues, classifies priority & type with AI, creates Notion tasks
PR Review	Reviews PR diffs, scores code quality 1-10, posts GitHub comments, creates Notion approval gates
Sprint Planner	Selects top tasks from backlog, estimates story points with AI, populates Notion sprint board
Daily Report	Aggregates sprint metrics, generates standup summary, saves report to Notion

The agents chain together into a full pipeline:

GitHub Issues/PRs → OpenAI Agents → Human Review in Notion → Notion Databases

The dashboard provides real-time SSE streaming of agent activity, live stat cards, a kanban sprint board, and a full pipeline visualization.

Key design decision: The PR Review agent creates human-in-the-loop approval gates in Notion when it finds low-quality PRs (score < 6). AI never takes destructive action without human sign-off.

Screenshots

Dashboard

Pipeline Running

AI Agent Output

Tasks View	Sprint Board	Reports

Notion Integration

Tasks Database	Sprint Board	Agent Reports

Video Demo

Show us the code

stackmasteraliza / notionops-ai

Autonomous AI workflow engine — 4 Gemini-powered agents that triage GitHub issues, review PRs, plan sprints, and generate standups, all coordinated through Notion.

NotionOps AI — Software Dev Pipeline That Runs Itself 🤖

Notion MCP Challenge Submission — An autonomous AI workflow engine that closes the loop between GitHub, OpenAI, human judgment, and Notion — in real time.

What It Does

Most dev teams have a painful daily ritual: check GitHub for new issues, triage them manually, review PRs, update Notion, plan the sprint, write the standup. NotionOps AI eliminates every step of that with four specialized AI agents and a real-time neon dashboard.

GitHub Issues/PRs  →  OpenAI Agents  →  Human Review Gate  →  Notion (Tasks · Sprint · Reports)
        ↑                                           |
        └───────────── feedback loop ───────────────┘

One click. The pipeline runs itself.

Demo Video

Four AI Agents

Agent	What it does	Output
🔍 Issue Triage	Fetches all open GitHub issues, classifies each as Bug/Feature/Issue with High/Medium/Low priority	Notion task per issue + triage report
👀 PR Review	Reviews every open PR, scores code

…

View on GitHub

How I Used Notion MCP

Notion is the central coordination layer between AI agents and humans. Four databases drive the entire workflow:

1. Tasks Database
AI-triaged GitHub issues land here with structured metadata (priority, type, status, agent notes, GitHub URL). This is the single source of truth — the Sprint Planner reads from it, and humans can override AI classifications directly in Notion.

2. Approvals Database
When the PR Review agent finds a problematic PR, it creates an approval page with its recommendation. Team members review and approve/reject directly in Notion. This is the human-in-the-loop gate — downstream agents respect these decisions.

3. Sprint Database
The Sprint Planner reads pending tasks from Notion, uses AI to estimate complexity and assign Fibonacci story points, then writes selected tasks back with Backlog/In Progress/Done status tracking. The dashboard renders this as a live kanban board.

4. Reports Database
Daily standup summaries are generated from sprint data and stored as rich-text report pages. This creates an automatic paper trail of team velocity and AI-generated insights over time.

The key unlock: agents write structured data into Notion, humans make decisions in a familiar interface, and downstream agents read those decisions to continue the workflow. No context switching between GitHub, AI tools, and project management — it all flows through Notion.

Tech Stack

Runtime: Node.js + TypeScript
AI: OpenAI via OpenRouter (structured JSON outputs)
APIs: Notion API, GitHub REST API (Octokit)
Server: Express.js with Server-Sent Events
Frontend: Vanilla HTML/CSS/JS (zero framework dependencies)

About Me

I'm Aliza Ali — a developer who loves building AI-powered tools that solve real workflow problems. If you liked this project, check out my other challenge submission:

FixForward: One Command to Go from Broken Build to Ready-to-Merge PR — A CLI autopilot that detects failing tests, classifies bugs, generates fixes via GitHub Copilot CLI, and creates verified PRs. One command. Three ecosystems. Zero manual patching.

Want to know more? Visit alizaali.com

Auto-Generate Swagger Docs in Laravel — Zero Annotations, Zero Config

Aliza Ali — Wed, 18 Feb 2026 17:55:16 +0000

Writing Swagger Annotations Is Pain. What If You Didn't Have To?

Be honest — how many times have you:

Skipped API documentation because @OA\Get annotations are a nightmare?
Spent more time writing Swagger comments than actual business logic?
Shipped an API with zero docs because "we'll add them later" (you didn't)?
Manually maintained a Postman collection that's always 3 endpoints behind?

What if your Laravel app could scan your controllers, read your FormRequest rules, and generate a complete Swagger UI automatically?

No @OA\ annotations. No YAML files. No config. Just your existing code.

Introducing: Laravel API Response Builder

composer require stackmasteraliza/laravel-api-response

v4.7.0 | Laravel 10, 11 & 12 | PHP 8.1+ | MIT License
GitHub | Packagist

The all-in-one Laravel API toolkit:

Auto-generated Swagger/OpenAPI docs — no annotations
One-click export to Postman & Insomnia
Standardized JSON responses
WebSocket testing built-in
API versioning out of the box

Zero configuration required.

Installation (30 Seconds)

composer require stackmasteraliza/laravel-api-response

That's it. No config publishing. No migrations. No setup wizards.

Your Swagger docs are already live at /api-docs.

Auto-Generated Swagger Docs (The Main Event)

This is why you're here. You don't write a single @OA\ annotation.

The package scans your controllers, detects response methods like ApiResponse::success() and ApiResponse::created(), reads your FormRequest validation rules, and generates a complete OpenAPI 3.0 specification — automatically.

Visit /api-docs and you get:

Beautiful, modern Swagger UI with dark/light theme toggle
Every endpoint documented with correct HTTP methods
Request body schemas auto-generated from your FormRequest rules
Response schemas matching your actual response structure
Try-it-out functionality — test endpoints right from the browser

How It Detects Everything

// The package sees this in your controller...
public function store(StoreUserRequest $request)
{
    $user = User::create($request->validated());
    return ApiResponse::created($user, 'User created');
}

// ...reads your FormRequest rules...
class StoreUserRequest extends FormRequest
{
    public function rules(): array
    {
        return [
            'name' => 'required|string|max:255',
            'email' => 'required|email|unique:users',
            'password' => 'required|min:8',
        ];
    }
}

Result: A fully documented POST endpoint in Swagger with request body schema, required fields, validation types, and a 201 Created response — all without you writing a single doc comment.

Want Even More Control? Use PHP Attributes

use Stackmasteraliza\ApiResponse\Attributes\ApiEndpoint;
use Stackmasteraliza\ApiResponse\Attributes\ApiRequestBody;

#[ApiEndpoint(
    summary: 'Create a new user',
    description: 'Register a new user account',
    tags: ['Users']
)]
#[ApiRequestBody(
    properties: ['name' => 'string', 'email' => 'string', 'password' => 'string'],
    required: ['name', 'email', 'password']
)]
public function store(StoreUserRequest $request): JsonResponse
{
    $user = User::create($request->validated());
    return ApiResponse::created($user, 'User created');
}

Attributes are optional — use them only when you want to add summaries, descriptions, or override auto-detected schemas.

Export to Postman & Insomnia (One Click)

From the Swagger UI, export your entire API documentation:

Format	Use Case
Postman	Import directly into Postman
Insomnia	Import directly into Insomnia
JSON	CI/CD pipelines, SDK generation
YAML	Human-readable specs

Your Postman collection is always in sync with your code. No manual maintenance.

API Versioning in Swagger UI

API_DOCS_VERSIONING=true

The package auto-detects api/v1/*, api/v2/* patterns and adds a version switcher in the Swagger UI. Each version gets its own OpenAPI spec. Your frontend team can browse docs for any version.

WebSocket Testing (Yes, In Swagger)

Test WebSocket connections directly from the Swagger UI. Send messages, subscribe to channels, see real-time responses — with pre-built templates for Subscribe, Unsubscribe, Ping, and Client Events.

No Postman. No wscat. Just click and test.

But Wait — It's Also a Complete Response Builder

The Facade Way

use Stackmasteraliza\ApiResponse\Facades\ApiResponse;

class UserController extends Controller
{
    public function index()
    {
        $users = User::paginate(15);
        return ApiResponse::success($users, 'Users retrieved');
    }

    public function store(StoreUserRequest $request)
    {
        $user = User::create($request->validated());
        return ApiResponse::created($user, 'User created');
    }

    public function destroy(User $user)
    {
        $user->delete();
        return ApiResponse::noContent();
    }
}

Or Use the Trait

use Stackmasteraliza\ApiResponse\Traits\HasApiResponse;

class UserController extends Controller
{
    use HasApiResponse;

    public function index()
    {
        return $this->success(User::paginate(15), 'Users retrieved');
    }
}

Both give you perfectly consistent responses:

{
    "status_code": 200,
    "success": true,
    "message": "Users retrieved",
    "data": [
        { "id": 1, "name": "John Doe" },
        { "id": 2, "name": "Jane Doe" }
    ],
    "meta": {
        "current_page": 1,
        "per_page": 15,
        "total": 50,
        "last_page": 4,
        "from": 1,
        "to": 15,
        "links": {
            "first": "http://example.com/api/users?page=1",
            "next": "http://example.com/api/users?page=2"
        }
    }
}

Pagination metadata is automatically detected and included. No extra code.

Every Error Response You'll Ever Need

ApiResponse::badRequest('Invalid input');           // 400
ApiResponse::unauthorized('Token expired');          // 401
ApiResponse::forbidden('Admin only');                // 403
ApiResponse::notFound('User not found');             // 404
ApiResponse::conflict('Email already exists');       // 409
ApiResponse::validationError($errors);               // 422
ApiResponse::tooManyRequests('Slow down', 60);       // 429
ApiResponse::serverError('Something broke');          // 500
ApiResponse::serviceUnavailable('Back soon');         // 503

Consistent structure every time:

{
    "status_code": 422,
    "success": false,
    "message": "Validation failed",
    "errors": {
        "email": ["The email field is required."],
        "password": ["The password must be at least 8 characters."]
    }
}

Exception Handling That Just Works

Drop this into your bootstrap/app.php (Laravel 11+):

use Stackmasteraliza\ApiResponse\Exceptions\ApiExceptionHandler;

->withExceptions(function (Exceptions $exceptions) {
    $exceptions->render(function (Throwable $e, Request $request) {
        return (new ApiExceptionHandler())->handle($e, $request);
    });
})

Now every exception — ValidationException, ModelNotFoundException, AuthenticationException — returns a clean, consistent JSON response. No more HTML error pages in your API.

Testing Helpers

Write expressive API tests:

$response = $this->getJson('/api/users');

$response->assertApiSuccess()
         ->assertApiStatusCode(200)
         ->assertApiMessage('Users retrieved')
         ->assertApiHasData()
         ->assertApiPaginated();

Customize Everything

Publish the config and make it yours:

php artisan vendor:publish --tag=api-response-config

Change response keys, pagination keys, default messages, theme colors, branding — everything is configurable.

// config/api-response.php
'keys' => [
    'success'     => 'success',
    'message'     => 'message',
    'data'        => 'data',
    'errors'      => 'errors',
    'meta'        => 'meta',
    'status_code' => 'status_code',
],

Extend With Custom Macros

Need custom response types? The package is macroable:

ApiResponse::macro('banned', function (string $reason = 'Account suspended') {
    return $this->error($reason, 403);
});

// Then use it anywhere
return ApiResponse::banned('Your account has been suspended');

Why Developers Are Switching

Before	After
Writing `@OA\` annotations for hours	Auto-generated Swagger docs from code
Postman collections always outdated	One-click Postman/Insomnia export
No WebSocket documentation	Built-in WebSocket tester in Swagger
Inconsistent response formats	One standardized JSON structure
Custom exception handlers	Built-in error handling
Copy-paste response code	One-liner fluent methods

Quick Start Recap

# 1. Install
composer require stackmasteraliza/laravel-api-response

# 2. Use in controllers
# (Facade or Trait — your choice)

# 3. Visit /api-docs
# Your documentation is already there

Supports Laravel 10, 11, and 12 | PHP 8.1+

Let's Connect

If this package saves you time, give it a star on GitHub and share it with your team.

Got questions, ideas, or feature requests? Drop a comment below or open an issue on GitHub.

Follow me for more Laravel packages and PHP tips:

Dev.to: @stackmasteraliza
GitHub: @stackmasteraliza

Happy coding!
— Aliza Ali (@stackmasteraliza)

FixForward: One Command to Go from Broken Build to Ready-to-Merge PR

Aliza Ali — Sun, 15 Feb 2026 14:54:11 +0000

GitHub Copilot CLI Challenge Submission

This is my submission for the GitHub Copilot CLI Challenge.

What I Built

Every developer knows the pain: your build breaks, your tests fail, and suddenly you're down a rabbit hole of stack traces, file-hopping, and manual patching. I've been there one too many times, so I built FixForward — a CLI autopilot that takes you from broken tests to a verified, ready-to-merge PR in a single command.

pip install fixforward
fixforward run

That's it. One command.

FixForward detects your test framework, runs the suite, parses the failures, classifies each one, asks GitHub Copilot CLI to generate a minimal fix, applies it on a safe branch, re-runs your tests to verify the fix actually works, and generates a PR description with a confidence score. The entire pipeline is automated, and the entire tool is powered by Copilot CLI under the hood.

Demo

Here is FixForward running against a real broken Python project. It detects the failing test, classifies the bug as an assertion failure, generates a one-line fix via Copilot CLI, patches the file, re-runs the tests, and reports 95% confidence — all without leaving the terminal:

The Pipeline: How It Works

FixForward is not a wrapper around a single Copilot prompt. It's a full incident response pipeline with 8 distinct stages:

tests fail → parse output → classify failure → Copilot generates fix
     → apply on safe branch → re-run tests → confidence score → PR report

1. Detect — Scans for pytest.ini, package.json, or Cargo.toml to identify your ecosystem automatically. No config files, no setup.

2. Run Tests — Executes your test suite (pytest, npm test, or cargo test) and captures full raw output.

3. Parse — Custom parsers extract individual failures with file paths, line numbers, error messages, and tracebacks. This isn't regex on the whole blob — there are dedicated parsers for pytest, Jest/Mocha, and cargo test that understand each format's quirks.

4. Classify — Categorizes every failure using heuristic pattern matching:

Category	Examples	Confidence
`syntax_error`	`SyntaxError`, `IndentationError`, `Unexpected token`	95%
`dependency`	`ModuleNotFoundError`, `Cannot find module`	90%
`api_change`	`AttributeError`, `TypeError` (wrong args)	85%
`assertion`	`AssertionError`, `assert_eq!`, `expect().toEqual()`	85%
`env_mismatch`	Version conflicts, missing commands	80%
`lint`	Flake8, ESLint, Clippy warnings	75%
`flaky_test`	Timeouts, connection refused, intermittent	60%

5. Generate Patch — Sends structured failure context + relevant source files to GitHub Copilot CLI (gh copilot -p) for a minimal fix. Copilot reads the actual code, understands the bug, and generates the smallest possible change.

6. Apply — Creates a fixforward/auto-* branch, writes the patched files, and commits. Your working branch is never touched.

7. Verify — Re-runs the entire test suite on the fix branch and computes a before/after confidence score.

8. Report — Generates a Markdown PR title and body with what changed, why, and the verification results.

Screenshots

Full Autopilot Run

The complete pipeline from broken tests to verified fix:

Diagnose Mode

Use fixforward diagnose to inspect failures without applying any changes:

Dependency Detection

FixForward recognizes when the fix isn't a code change but a missing package:

Multi-Ecosystem: Node.js Support

Same pipeline, different ecosystem. Jest failures parsed and classified automatically:

Three Ecosystems, One Interface

Ecosystem	Test Command	What Gets Parsed
Python	`pytest --tb=long -v`	Failures, tracebacks, assertion details, collection errors
Node.js	`npm test`	Jest and Mocha output, suite-level failures, missing modules
Rust	`cargo test`	Panics, `assert_eq!` failures, test summaries

I didn't just support one language and call it a day. Each ecosystem has its own parser that understands the specific output format — pytest tracebacks look nothing like Jest failures, and cargo test panics are their own thing entirely. FixForward handles all of them.

Safety First

I spent a lot of time thinking about what could go wrong. When you're auto-applying code patches, you better not destroy someone's working tree. FixForward has several layers of protection:

Never touches your working branch — all fixes go on fixforward/auto-* branches
Stashes dirty state — uncommitted changes are saved and restored on rollback
Patch preview — see the exact diff before confirming
Dry-run mode — fixforward run --dry-run diagnoses without touching anything
One-command rollback — fixforward rollback undoes everything cleanly
State persistence — rollback info stored at ~/.fixforward/state.json

I wanted this to be a tool you could trust running in your repo without hesitation.

My Experience with GitHub Copilot CLI

Copilot CLI is not just a helper in this project — it is the engine. FixForward uses gh copilot -p at its core to generate the actual code fixes. Here's what that looks like internally:

gh copilot -- -p "I have a python project with failing tests.
  The test test_divide in test_app.py fails with AssertionError:
  assert 3.333 == 3. Generate a minimal fix..." \
  --allow-all-tools --add-dir ./project --silent

Copilot reads the source files through --add-dir, understands the test context, and generates the smallest code change. FixForward then parses Copilot's response (which can come in several formats — code blocks, file headers, inline diffs), extracts the patched files, and applies them.

Building the Copilot response parser was one of the trickier parts. Copilot doesn't always respond in the same format, so I built multiple parsing strategies:

Fenced code blocks with FILE: markers
Filename headers (### file.js, file.js, backtick file.js) followed by code blocks
Language-tagged blocks matched to project files
Fuzzy file matching against the project tree (skipping node_modules)

If one strategy fails, the next one kicks in. This makes FixForward resilient to Copilot's varying output formats.

I also used Copilot CLI extensively during development — for scaffolding parsers, debugging edge cases in Jest output handling, and figuring out the right subprocess patterns for capturing test output across platforms.

Try It Yourself

The repo includes ready-made broken demo projects:

git clone https://github.com/stackmasteraliza/fixforward.git
cd fixforward

# Python: division bug (a / b should be a // b)
fixforward run --path demo/broken_python

# Node.js: truncation bug ("..." becomes "..")
fixforward diagnose --path demo/broken_node

# Rust: off-by-one in clamp()
fixforward diagnose --path demo/broken_rust

# Safe mode: see the diagnosis without changing anything
fixforward run --path demo/broken_python --dry-run

Install from PyPI:

pip install fixforward

Architecture

fixforward/
├── cli.py          # argparse CLI: run, diagnose, rollback
├── detector.py     # Ecosystem detection + test runner
├── classifier.py   # Regex heuristic failure classification
├── copilot.py      # GitHub Copilot CLI integration
├── patcher.py      # Safe branch creation + file patching
├── verifier.py     # Test re-run + confidence scoring
├── reporter.py     # PR title/body generation
├── display.py      # Rich-based terminal UI
├── state.py        # Rollback state persistence
└── parsers/
    ├── pytest_parser.py   # pytest output parser
    ├── npm_parser.py      # Jest/Mocha output parser
    └── cargo_parser.py    # cargo test output parser

Only one dependency: rich. Everything else is Python standard library.

I built Spotify Wrapped for Git using GitHub Copilot CLI

Aliza Ali — Sun, 15 Feb 2026 06:37:15 +0000

This is a submission for the GitHub Copilot CLI Challenge

What I Built

git-wrapped — Spotify Wrapped, but for your Git history.

Every December, Spotify tells you what kind of listener you are. I wanted the same thing for coding. What if your terminal could tell you that you're a Night Owl who codes at 2 AM, or a Code Surgeon who deletes more than they write?

git-wrapped is a Python CLI tool that analyzes any Git repository and generates a beautiful, colorful terminal report. No browser, no dashboard, no account — just run a command and see your year in code.

The Full Feature Set

The Numbers — Total commits, files changed, lines added/deleted, net line impact, active days
Activity Heatmap — A GitHub-style contribution calendar rendered entirely in your terminal using Unicode block characters
When You Code — Hour-of-day and day-of-week bar charts showing your coding rhythm
Top Files — Leaderboard of your most frequently modified files
Languages — Programming language breakdown with percentage bars
Streaks & Records — Longest streak, current streak, busiest single day, best month
Coder DNA — A personality assessment based on your commit patterns: Night Owl, Early Bird, Weekend Warrior, Streak Master, Feature Machine, Code Surgeon, or Balanced Builder
Fun Facts — Holiday commits, longest/shortest commit messages, contributor count, productivity stats
Compare Mode — Year-over-year comparison (--compare 2024 2025) with delta percentages and personality shift tracking
Share Card — A copy-pasteable plain text card for sharing on social media (--share)
JSON Export — Dump raw stats as JSON for further analysis or integrations

Why I Built This

I spend a lot of time in the terminal. I wanted something that celebrates the work developers do — not just the PRs that get merged, but the late-night debugging sessions, the weekend side projects, the 14-day commit streaks that nobody notices.

git-wrapped makes that visible. And it's fun.

Demo

GitHub repo: stackmasteraliza/git-wrapped

Try it yourself

# Install from PyPI
pip install git-wrapped

# Or install from source
git clone https://github.com/stackmasteraliza/git-wrapped.git
cd git-wrapped
pip install -e .

# Run on any repo
git-wrapped

# Analyze a specific year
git-wrapped --year 2025

# Compare two years
git-wrapped --compare 2024 2025

# Generate a share card
git-wrapped --share

Tech Stack

Python 3.8+ — Core language
Rich — Terminal formatting (panels, tables, progress bars, styled text)
Git log parsing — Custom parser using --numstat and --format for file-level stats
Zero external API calls — Everything runs locally, your data never leaves your machine

One external dependency. That's it.

My Experience with GitHub Copilot CLI

GitHub Copilot CLI was my pair programmer for this entire project. Instead of tab-switching between Stack Overflow, Git docs, and Rich documentation, I stayed in my terminal and asked Copilot directly.

Here's exactly how I used it at each stage of development:

1. Understanding git log format

The first challenge was figuring out how to extract structured data from git log. I asked Copilot CLI to explain the --format flags, and it gave me a clear breakdown of every placeholder — %H for hash, %an for author name, %aI for ISO date, %s for subject line — plus how --numstat adds per-file insertion/deletion stats and how >>> delimiters can separate commits for reliable parsing.

This saved me from trial-and-error with Git's dense documentation.

2. Calculating commit streaks

Computing the longest daily commit streak was trickier than expected. I needed to handle gaps, deduplicate dates, and track both the longest historical streak and the current active one.

I asked Copilot CLI for approaches and it gave me multiple solutions — a Python version using datetime.timedelta to detect consecutive days, and even a Bash one-liner. I adapted the Python approach directly into my analyzer:

# Copilot helped me arrive at this pattern
sorted_dates = sorted(set(commit_dates))
streak, max_streak = 1, 1
for i in range(1, len(sorted_dates)):
    if (sorted_dates[i] - sorted_dates[i-1]).days == 1:
        streak += 1
        max_streak = max(max_streak, streak)
    else:
        streak = 1

3. Grouping commits by hour of day

For the "When You Code" charts, I needed to count commits grouped by hour. Copilot CLI gave me multiple shell approaches — from simple cut pipelines to awk loops — which helped me understand the data shape before writing the Python version.

Seeing the shell approach first made the Python implementation obvious.

4. Rendering the terminal heatmap

This was the hardest visual to get right. A GitHub-style contribution heatmap, but in the terminal, using colored Unicode blocks.

I asked Copilot CLI how to render a colored heatmap using Python's Rich library, and it showed me two approaches:

A Table-based approach using Rich's Table with colored cells
A block character approach mapping values to █ characters with ANSI colors

I ended up combining both — using Rich's Console for color management and block characters for the grid cells:

colors = ["bright_black", "dark_green", "green", "bright_green"]
char = "█"
for week in range(weeks):
    for day in range(7):
        intensity = get_intensity(data[week][day])
        output += f"[{colors[intensity]}]{char}[/]"

The Impact

Without Copilot CLI, each of these problems would have meant opening a browser, scanning docs, finding a relevant example, adapting it, and testing. That cycle breaks flow.

With Copilot CLI, the cycle was: ask a question → get a working answer → adapt and move on. I stayed in my terminal the entire time. The cognitive load dropped and I could focus on making the output feel delightful instead of fighting implementation details.

It felt less like using a tool and more like pair programming with someone who has every man page memorized.

Challenges & Discoveries

The heatmap was the hardest part. Terminals don't have pixels — you're working with a character grid where each "cell" is a text character. Getting the heatmap to look like GitHub's contribution graph required careful math: mapping 52 weeks × 7 days into a grid, choosing the right Unicode block characters, and picking green shades that look good across different terminal themes.

Personality detection was surprisingly fun. The "Coder DNA" feature assigns you a personality based on your commit patterns. Calibrating the thresholds (e.g., "30% of commits after 10 PM = Night Owl") required running it against a bunch of real repos to make sure the labels felt accurate and fun, not arbitrary.

Rich is incredible. Python's Rich library does the heavy lifting for all the terminal visuals — panels, tables, progress bars, colored text. It's the reason git-wrapped looks polished without needing a web UI.

What Makes This Special

For developers:

See your coding habits visualized in seconds
Discover patterns you didn't know you had (turns out I code most on Thursdays)
A fun conversation starter in team standups

For teams:

Run it on shared repos to see team-wide patterns
Compare year-over-year to track how the team's rhythm evolves

For the community:

Fully open source — fork it, extend it, make it yours
Single dependency — easy to install anywhere
Privacy-first — everything runs locally, no data leaves your machine

Built with Python, Rich, and a lot of late-night commits. Powered by GitHub Copilot CLI.

GitHub Repository: stackmasteraliza/git-wrapped

DEV Community: Aliza Ali

NotionOps AI — 4 AI Agents That Run Your Dev Workflow End-to-End

What I Built

Screenshots

Video Demo

Show us the code

stackmasteraliza / notionops-ai

Autonomous AI workflow engine — 4 Gemini-powered agents that triage GitHub issues, review PRs, plan sprints, and generate standups, all coordinated through Notion.

NotionOps AI — Software Dev Pipeline That Runs Itself 🤖

What It Does

Demo Video

Four AI Agents

How I Used Notion MCP

Tech Stack

About Me

Auto-Generate Swagger Docs in Laravel — Zero Annotations, Zero Config

Writing Swagger Annotations Is Pain. What If You Didn't Have To?

Introducing: Laravel API Response Builder

Installation (30 Seconds)

Auto-Generated Swagger Docs (The Main Event)

How It Detects Everything

Want Even More Control? Use PHP Attributes

Export to Postman & Insomnia (One Click)

API Versioning in Swagger UI

WebSocket Testing (Yes, In Swagger)

But Wait — It's Also a Complete Response Builder

The Facade Way

Or Use the Trait

Every Error Response You'll Ever Need

Exception Handling That Just Works

Testing Helpers

Customize Everything

Extend With Custom Macros

Why Developers Are Switching

Quick Start Recap

Links

Let's Connect

FixForward: One Command to Go from Broken Build to Ready-to-Merge PR

What I Built

Demo

The Pipeline: How It Works

Screenshots

Full Autopilot Run

Diagnose Mode

Dependency Detection

Multi-Ecosystem: Node.js Support

Three Ecosystems, One Interface

Safety First

My Experience with GitHub Copilot CLI

Try It Yourself

Architecture

Links

I built Spotify Wrapped for Git using GitHub Copilot CLI

What I Built

The Full Feature Set

Why I Built This

Demo

Try it yourself

Tech Stack

My Experience with GitHub Copilot CLI

1. Understanding git log format

2. Calculating commit streaks

3. Grouping commits by hour of day

4. Rendering the terminal heatmap

The Impact

Challenges & Discoveries

What Makes This Special