Project: Creative Apps/GitHub Copilot - Repo Check AI

Track

Creative Apps (GitHub Copilot)

Project Name

Repo Check AI

GitHub Username

glaucia86

Repository URL

https://github.com/glaucia86/repocheckai

Project Description

What does your project do?
Repo Doctor is an AI-powered CLI tool that analyzes the health of a GitHub repository and produces a structured diagnosis with recommended improvements.

What problem does it solve?
Repository audits are usually manual and time-consuming: checking documentation, CI/CD, tests, governance, and security practices across many files and settings. Repo Doctor automates this assessment, helping maintainers and teams quickly understand risks, prioritize fixes, and improve project quality and maintainability.

What are the key features?

• Comprehensive health checks (6 areas): documentation & onboarding, developer experience, CI/CD, quality & testing, governance, and security.
• Two analysis modes:
  • Quick Scan: GitHub API-based review (fast checks and governance assessment).
  • Deep Analysis: full source scanning (deeper code/architecture review).
• Actionable, evidence-based reporting: health score (0–100), prioritized findings (P0/P1/P2), and clear remediation steps (often with code examples).
• Interactive CLI workflow: slash commands (e.g., /analyze, /deep, /export) and real-time/streaming output for a better developer experience.
• Auto-publish to GitHub Issues (optional): generate structured issues for each finding to support collaboration and continuous tracking.
• Security-first approach: prompt-injection protections and local execution (no data storage).

Demo Video or Screenshots

Demo Video:

• https://youtu.be/Yci-SV3xrv0

Screenshots:

• https://github.com/glaucia86/repocheckai/tree/main/resources

Official Website:

• https://glaucia86.github.io/repocheckai/

Live Demo (optional):

• N/A (the project is primarily a CLI tool/ Web UI)

Primary Programming Language

TypeScript/JavaScript

Key Technologies Used

• TypeScript (main codebase)
• Node.js (18+) (runtime for the CLI tool)
• GitHub Copilot SDK (AI agent runtime and access to multiple LLM models for analysis)
• GitHub REST API (repository metadata/file inspection and optional GitHub Issue creation with --issue)
• Repomix (repository packing for deep, full-source analysis)
• Zod (schema validation and safe option parsing)
• Vitest (unit/integration testing)
• GitHub Actions (CI/CD workflows)
• GitHub Pages (official website / documentation site)
• HTML/CSS/JavaScript (static site assets under site/)

Submission Type

Individual

Team Members

No response

Submission Requirements

• My project meets the track-specific challenge requirements
• My repository includes a comprehensive README.md with setup instructions
• My code does not contain hardcoded API keys or secrets
• I have included demo materials (video or screenshots)
• My project is my own work with proper attribution for any third-party code
• I agree to the Code of Conduct
• I have read and agree to the Disclaimer
• My submission does NOT contain any confidential, proprietary, or sensitive information
• I confirm I have the rights to submit this content and grant the necessary licenses

Quick Setup Summary

1. Prerequisites: Node.js 18+ and an active GitHub Copilot subscription (recommended: authenticate with gh auth login).
2. Install: npm install -g repocheckai
3. Run (CLI): repocheck (interactive) or repocheck owner/repo (direct analysis).
4. Run (Local Web UI): clone the repo and start the local services:
   git clone https://github.com/glaucia86/repocheckai.git && cd repocheckai && npm install
npm run dev:local-ui (runs API + Web UI)
   (or separately: npm run dev:web-ui:api and npm run dev:web-ui)
5. Optional: publish findings as GitHub Issues with --issue (requires a GitHub token with Issues read/write permission).

Technical Highlights

• Agentic analysis built on GitHub Copilot SDK: I designed the tool as an AI “doctor” that can reason over repository context, select the right tools, and produce evidence-backed recommendations instead of just rule-based lint output.
• Two-tier analysis strategy (speed vs depth): a Quick Scan mode (GitHub API with limited reads) for fast governance/onboarding checks, and a Deep Analysis mode (Repomix full-source packing) for more comprehensive architecture and code-quality review.
• Evidence-based reporting + prioritization: findings are grouped into 6 health categories and ranked as P0/P1/P2, with a health score and actionable remediation steps (often including concrete examples).
• Security-first prompt handling: repository file content is treated strictly as data and sanitized to reduce prompt-injection risk, improving the reliability of the analysis output.
• Workflow-ready automation: the optional --issue flow can publish structured GitHub issues automatically, turning analysis results into trackable work items for teams.
• Modular, maintainable architecture: clean separation of presentation (CLI/Web), application orchestration, infrastructure adapters (GitHub/providers), and domain schemas/validation (e.g., Zod), making it easy to extend categories, models, and outputs.

Challenges & Learnings

Building RepoCheckAI taught me that the hardest part of an AI-powered developer tool is not generating text, but producing reliable, actionable output under real-world constraints.

One major challenge was balancing analysis depth vs. speed/cost. Repositories vary widely in size and structure, and reading everything is slow and expensive. I solved this by designing two modes: a Quick Scan (API-based, limited reads) for fast governance checks and a Deep Analysis mode (full-source packing) for comprehensive reviews when needed.

Another challenge was trust and security. Repository files may contain content that tries to influence the model (prompt injection) or leak secrets. I learned to treat file content strictly as data, add sanitization/guardrails, and keep the workflow evidence-based (findings must point to concrete files or missing artifacts).

Authentication was also a real-world hurdle: the Copilot SDK and GitHub API have different auth paths and failure modes (401/403). Documenting a clear setup and troubleshooting guide was essential for good DX.

Overall, the key learning was that “agentic” tooling works best when it’s tool-driven, structured, and verifiable: small, composable tools; validated inputs; prioritized outputs (P0/P1/P2); and workflows that turn results into trackable GitHub issues.

Contact Information

https://www.linkedin.com/in/glaucialemos/

Country/Region

Brazil

This is a project submission rather than a scoped change request, and it provides no target file, test, or implementation entry point in the agentsleague repository. Review the linked RepoCheckAI repository and its README first; no definition of done for a contribution is provided here.