You are an expert software architect and technical project planner. Your task is to create a comprehensive technical implementation plan for a software project based on the provided inputs.
You are an expert developer capable of building a repository analysis application. Your goal is to create a comprehensive plan for implementing a web application that retrieves a GitHub repository identifier (e.g., 127.0.0.1:5001/kohya-ss/sd-scripts) and produces an interactive report usable as context for LLMs.
The web application should accept a GitHub repository ID in the specified URL format and generate an interactive repository report. This report should provide details such as code file descriptions and allow filtering by file extension. The app should collect all relevant information from the repository that an LLM would typically need to make informed decisions. It is up to you to decide what type of information to include, while also offering users the ability to fine-tune the process through settings.
Additionally, the application should support AI services that expose an OpenAI-compatible endpoint, enabling an AI-assisted repository analysis mode. Explore ideas for leveraging an LLM effectively to analyze repositories of varying sizes—from small personal projects to large enterprise solutions—while ensuring that context length is not a limiting factor.
AI-assisted analysis should remain optional, and the application must be fully functional and capable of delivering valuable insights even without AI support.
Also, keep the app as modular as possible to allow for the addition of new modules and functionality later on. For example, we might want to expand this tool into a prompt manager or even an AI Project Manager in the future.
Generate the following sections:
Generate a project name that is:
- Memorable and relevant
- Available as an npm package
- Has available common domain names
- Reflects the core functionality
Create a project hook that:
- Clearly states the value proposition
- Uses engaging, technical language
- Highlights unique features
- Is suitable for a technical README
- Includes an emoji that represents the project
Transform the project meta data into the following format:
project:
project_name: "Project Name 🚀" # Include emoji
core_concept: |
Brief description of the main project idea
project_hook: |
Project hook for catching users
key_features:
- Feature 1
- Feature 2
technical_constraints:
- "Must be web-based"
- Constraint 2
target_users: |
Description of who will use this systemBreak down the system into core components:
architecture:
frontend:
core_ui_components:
- Component 1
- Component 2
state_management: |
Description of state management approach
data_flow_patterns:
- Pattern 1
- Pattern 2
user_interactions:
- Interaction 1
- Interaction 2
backend:
services_structure:
- Service 1
- Service 2
api_design:
endpoints:
- Endpoint 1
- Endpoint 2
data_processing:
- Process 1
- Process 2
external_integrations:
- Integration 1
- Integration 2
data:
storage_solutions:
- Solution 1
- Solution 2
data_models:
- Model 1
- Model 2
caching_strategy: |
Description of caching approach
data_flow: |
Description of data flow
infrastructure:
deployment_requirements:
- Requirement 1
- Requirement 2
scaling_considerations:
- Consideration 1
- Consideration 2
service_dependencies:
- Dependency 1
- Dependency 2For each major component, specify:
components:
- name: "Component Name"
purpose: |
Clear statement of component's role
technical_requirements:
libraries:
- Library 1
- Library 2
performance:
- Performance requirement 1
security:
- Security requirement 1
integration_points:
- Integration point 1
implementation_details:
data_structures:
- Structure 1
algorithms:
- Algorithm 1
api_contracts:
- Contract 1
error_handling:
- Strategy 1Convert the implementation components into concrete tasks:
tasks:
- id: "TASK-001"
category: "frontend/backend/infrastructure"
description: |
Specific, actionable task description
technical_details:
required_technologies:
- Technology 1
- Technology 2
implementation_approach: |
Detailed implementation approach
expected_challenges:
- Challenge 1
- Challenge 2
acceptance_criteria:
- Criterion 1
- Criterion 2
complexity:
estimated_loc: 150 # Must be < 200
estimated_hours: 6 # Must be < 8
dependencies:
- "TASK-000"Input:
project:
core_concept: |
A web application that analyzes GitHub repositories and generates AI-ready documentation.
key_features:
- Repository analysis
- Documentation generation
- AI context creation
technical_constraints:
- Must be web-based
- Support large repositories
- Generate structured output
target_users: |
Developers integrating repositories with LLMs-
Technical Depth
- Every component should have clear technical specifications
- Include specific libraries and tools where relevant
- Define interfaces and data structures
- Specify performance requirements
-
Modularity
- Break down components into independent modules
- Define clear interfaces between components
- Enable parallel development
- Consider future extensibility
-
Implementation Focus
- Provide actionable technical details
- Include specific methodologies and patterns
- Define clear acceptance criteria
- Specify testing requirements
-
Task Specificity
- Tasks should be atomic and measurable
- Include technical requirements
- Specify dependencies clearly
- Define completion criteria
Your response should follow this structure:
- Project Identity (name and hook)
- Technical Architecture Overview
- Detailed Component Specifications
- Task Breakdown
- Implementation Dependencies
- Focus on technical implementation details
- Provide specific, actionable information
- Include concrete examples where helpful
- Define clear interfaces and contracts
- Specify exact technical requirements
- Include performance constraints
- Define error handling approaches
- Specify testing requirements
- MAKE THE BEST APP POSSIBLE
- Analyze the topic and the idea at hand and deeply analyze it for "genius ideas & eureka" moments
- If similar apps already exist think of ways on how to improve on them to make our app stand out
- If the user forgot important use cases or ideas feel free to add them as you see fit
- End your report by a short section about why you think this app is going to be amazing
The goal is to generate a technical plan that can be immediately used to begin implementation, with clear tasks that can be assigned to developers.