@akm1923main/init-project 1.0.0

package/templates/02_Skills/Legacy_Prompts/Generate_prd.md

@@ -0,0 +1,129 @@
+```md
+# 🚀 Production-Grade Agentic RAG System  
+## (Qdrant + Groq GPT-OSS-120B + Modular Backend Architecture)
+
+You are a **Senior AI Systems Architect and Production Backend Engineer**.
+
+Your task is to design and implement a **fully production-grade Agentic RAG system** using:
+
+- **Vector Database:** Qdrant (self-hosted/local)
+- **LLM Provider:** Groq API
+- **Model:** gpt-oss-120b
+- **Backend Framework:** FastAPI (Python)
+- **Architecture Pattern:** Agentic RAG (Planner + Tools + Memory + Validation)
+
+---
+
+# 🔴 MANDATORY RULE
+
+You must:
+
+1. **FIRST generate a complete, detailed PRD (Product Requirements Document).**
+2. Only after the PRD is complete and coherent, proceed to implementation.
+3. Do NOT generate toy code.
+4. Do NOT collapse modules.
+5. Do NOT simplify architecture.
+6. Everything must be production-ready.
+
+---
+
+# PHASE 1 — PRODUCT REQUIREMENTS DOCUMENT (PRD)
+
+Generate a complete, structured PRD with the following sections:
+
+---
+
+## 1️⃣ Executive Summary
+
+- What system is being built
+- Why Agentic RAG instead of traditional RAG
+- Core system goals
+- Explicit non-goals
+- Key architectural principles
+
+---
+
+## 2️⃣ Functional Requirements
+
+System must support:
+
+- Multi-hop reasoning
+- Iterative retrieval loop
+- ReAct-style agent loop
+- Query rewriting
+- Hybrid-retrieval-ready architecture (even if initially dense-only)
+- Metadata filtering
+- Tool usage framework
+- Short-term memory
+- Long-term memory (stored in Qdrant)
+- Context compression
+- Reranking support
+- Structured citations
+- Answer validation step
+- Iteration hard limits
+- Token budget enforcement
+- Config-driven behavior
+- Evaluation hooks
+- Streaming support
+
+---
+
+## 3️⃣ Non-Functional Requirements
+
+Define:
+
+- Latency targets
+- Cost control mechanisms
+- Scalability strategy
+- Modularity constraints
+- Security requirements
+- Observability requirements
+- Rate limiting
+- Prompt injection resistance
+- Fault tolerance
+- Retry logic
+- Circuit breaker design
+
+---
+
+## 4️⃣ System Architecture (Deep Design)
+
+Clearly define:
+
+### Online Query Flow
+
+User  
+→ API  
+→ Router  
+→ Planner  
+→ Tool Execution Loop  
+→ Retriever  
+→ Memory  
+→ Generator  
+→ Validator  
+→ Response
+
+### Offline Ingestion Flow
+
+Document Loader  
+→ Cleaning  
+→ Chunking  
+→ Embedding  
+→ Qdrant Upsert  
+
+Define:
+
+- Agent loop state schema
+- Memory schema
+- Retrieval schema
+- Tool abstraction interface
+- Failure handling logic
+- Stop conditions
+
+---
+
+## 5️⃣ Backend Folder Structure (MANDATORY)
+
+All backend code must live inside:
+
+```

package/templates/02_Skills/Legacy_Prompts/IDEA.md

@@ -0,0 +1,188 @@
+# 💡 IDEA.md — PROJECT CONCEPT & ANALYSIS TEMPLATE
+
+## 🏷️ 1. Project Title
+
+> Give your idea a concise, descriptive name.
+
+Example: *Agentic Retrieval-Augmented Generation Platform (Agentic RAG System)*
+
+**Title:**
+
+---
+
+## 📌 2. Primary Goal
+
+> What are you trying to build?
+> What is the core functionality or capability you expect?
+
+**Goal Description:**
+
+---
+
+## 📍 3. Context & Background
+
+> Describe the context of this idea. Why did you think of it?
+> Include:
+
+- Business problem
+- Technical problem
+- User pain points
+- Current limitations in existing solutions
+
+**Background:**
+
+---
+
+## 🎯 4. Target Users & Personas
+
+> Who will use this system?
+> List expected user roles and personas.
+
+Example:
+
+- AI Engineer
+- Technical Writer
+- Knowledge Worker
+- System Admin
+
+**Users & Personas:**
+
+---
+
+## 🧩 5. Expected Capabilities
+
+> List the major capabilities expected from the system.
+
+E.g.:
+
+- Multi-hop reasoning
+- Iterative retrieval
+- Tool invocation
+- Memory persistence
+
+**Capabilities:**
+
+---
+
+## 🧪 6. Key Requirements (Functional)
+
+> High-level functional requirements.
+
+List them as bullet points.
+
+**Functional Requirements:**
+
+---
+
+## 🔒 7. Key Constraints & Assumptions
+
+> List constraints on environment, performance, reliability, cost, tech stack, etc.
+> List your assumptions.
+
+**Constraints:**
+**Assumptions:**
+
+---
+
+## 📊 8. Success Metrics
+
+> How will success be measured?
+> List business & technical KPIs.
+
+**Success Metrics:**
+
+---
+
+## 🔍 9. Open Questions
+
+> List questions that need clarification before scoping.
+> Example:
+
+- Which model family?
+- Which vector DB?
+- On-prem vs Cloud?
+
+**Open Questions:**
+
+---
+
+## 🚧 10. Risks & Concerns
+
+> Possible technical, market, operational risks.
+> Include concerns you already see.
+
+**Risks:**
+
+---
+
+## 🔗 11. Dependencies
+
+> Dependencies on:
+
+- External APIs
+- Data sources
+- Third-party platforms
+- Regulatory requirements
+- Internal teams
+
+**Dependencies:**
+
+---
+
+## 📈 12. Feasibility Indicators
+
+> What makes you think this idea is feasible?
+> Include:
+
+- Prior work
+- Known technologies
+- Reference systems
+
+**Feasibility:**
+
+---
+
+## 🧠 13. Enrichment Instructions (For LLM / Agent)
+
+You must treat the above idea and do the following *before* generating a PRD:
+
+1. **Perform web research** to enrich this idea, including:
+
+   - Similar products / competitors
+   - Known architectural patterns
+   - Known challenges
+   - Relevant benchmarks
+   - Standard practices
+2. **Evaluate the idea for feasibility**, including:
+
+   - Technical feasibility
+   - Business feasibility
+   - Scalability considerations
+3. **Suggest improvements** where appropriate:
+
+   - Feature enhancements
+   - Risk mitigation strategies
+   - Alternate design options
+4. **Finalize a refined Idea Summary** that clearly explains:
+
+   - What the idea is
+   - Why it matters
+   - What success looks like
+   - What uncertainties remain
+5. **Output this refined interpretation in a well-structured summary**.
+
+---
+
+## 📝 14. Refined Idea (Leave blank, to be filled by agent)
+
+> (The agent should produce a refined version here)
+
+**Refined Idea Summary:**
+
+---
+
+## 🧾 15. Reference Links / Inputs
+
+> Paste any URLs, diagrams, research links here.
+
+**References:**

package/templates/02_Skills/Legacy_Prompts/Sharder.md

@@ -0,0 +1,359 @@
+---
+# 🏆 ENTERPRISE TASK ORCHESTRATION TEMPLATE (GOD MODE 9.8)
+
+```md
+# 🚀 ENTERPRISE TASK ORCHESTRATION TEMPLATE (GOD MODE 9.8)
+
+You are a **Principal Engineer + Staff Architect + Technical Execution Lead**.
+
+You will receive:
+
+- Finalized PRD
+- Finalized ARCHITECTURE.md
+
+Your responsibility is to convert them into a fully traceable, dependency-aware, production-grade execution system.
+
+⚠️ Follow structure strictly.
+⚠️ No implementation code.
+⚠️ No sprint theory.
+⚠️ No process abstraction beyond defined sections.
+
+This must feel like a real enterprise engineering execution artifact.
+---
+# ⚠️ CRITICAL RULES
+
+1. Every task must be atomic and implementable.
+2. Tasks must map directly to Architecture components.
+3. Each task must reference:
+   - Related PRD Section
+   - Related Architecture Section
+4. Dependencies must be explicit.
+5. Dependencies must be classified:
+   - Hard (blocking)
+   - Soft (non-blocking)
+6. Critical path must be identified.
+7. Parallelizable tasks must be clearly marked.
+8. Every task must include:
+   - Objective
+   - Description
+   - Deliverables
+   - Dependencies (Hard/Soft)
+   - Risks
+   - Acceptance Criteria
+   - Validation Steps
+   - Definition of Done
+   - Estimated complexity (S/M/L)
+   - Estimated effort range
+9. No task may exceed atomic scope.
+10. No architecture section may remain without task coverage.
+11. The system must support resuming work after interruption.
+12. DEVELOPMENT_CHECKLIST must enable granular progress tracking.
+
+---
+
+# 📁 OUTPUT STRUCTURE
+
+Generate:
+
+```
+
+Tasks/
+│
+├── TASK_PLAN.md
+├── DEVELOPMENT_CHECKLIST.md
+└── TASKS/
+├── TASK_001_<name>.md
+├── TASK_002_<name>.md
+├── TASK_003_<name>.md
+└── ...
+
+```
+
+Do not collapse structure.
+
+---
+
+# 1️⃣ TASK_PLAN.md
+
+Must contain:
+
+---
+
+## 1. Overview
+
+- System Name
+- PRD Version Reference
+- Architecture Version Reference
+- Total Task Count
+- Total Phases
+- Total Estimated Effort Range
+- Architecture Components Covered
+
+---
+
+## 2. Development Phases
+
+Phases must align to architecture layers:
+
+- Phase 1 — Core Infrastructure
+- Phase 2 — Data Layer
+- Phase 3 — API Layer
+- Phase 4 — Business Logic
+- Phase 5 — Async / Events
+- Phase 6 — Observability
+- Phase 7 — Security Hardening
+- Phase 8 — Performance Optimization
+- Phase 9 — Production Readiness
+
+For each phase include:
+
+- Phase Objective
+- Architecture Sections Covered
+- Task IDs in this phase
+- Entry Criteria
+- Exit Criteria
+- Phase Risk Level
+- Cross-Phase Dependencies
+
+---
+
+## 3. Critical Path Analysis
+
+Identify:
+
+- Foundational tasks
+- Blocking tasks
+- Long-lead tasks
+- High-risk tasks
+
+Provide dependency graph:
+
+```mermaid
+graph TD
+    TASK_001 --> TASK_004
+    TASK_004 --> TASK_009
+    TASK_009 --> TASK_015
+```
+
+Explain:
+
+* Why these are blocking
+* Which phases depend on them
+* What delays would impact system launch
+
+---
+
+## 4. Task Summary Table (Master Registry)
+
+| Task ID | Title | Phase | Arch Ref | PRD Ref | Complexity | Effort | Hard Deps | Soft Deps | Critical | Parallelizable |
+| ------- | ----- | ----- | -------- | ------- | ---------- | ------ | --------- | --------- | -------- | -------------- |
+
+---
+
+## 5. Architecture Coverage Validation
+
+For each Architecture Component:
+
+* Component Name
+* Responsible Task IDs
+* Validation Notes
+
+No component should be unassigned.
+
+---
+
+## 6. Risk Distribution Overview
+
+Summarize:
+
+* High-risk tasks
+* Integration-heavy tasks
+* Performance-sensitive tasks
+* Security-sensitive tasks
+
+---
+
+# 2️⃣ DEVELOPMENT_CHECKLIST.md
+
+This file must act as a live execution dashboard.
+
+---
+
+## Status Legend
+
+* 🔲 Not Started
+* 🟡 In Progress
+* ✅ Completed
+* 🚧 Blocked
+* 🔴 Critical Path
+
+---
+
+## Task Tracking Table (Detailed)
+
+| Task ID | Title | Status | Phase | Critical | Parallel | Owner | Start Date | End Date | Risk | Notes |
+| ------- | ----- | ------ | ----- | -------- | -------- | ----- | ---------- | -------- | ---- | ----- |
+
+---
+
+## Phase Completion Summary
+
+| Phase | Total Tasks | Completed | In Progress | Blocked | Remaining | % Complete |
+| ----- | ----------- | --------- | ----------- | ------- | --------- | ---------- |
+
+---
+
+## Architecture Coverage Tracker
+
+| Architecture Component | Implemented | Partially | Not Started |
+| ---------------------- | ----------- | --------- | ----------- |
+
+---
+
+## Risk Tracker
+
+| Task ID | Risk Level | Mitigation Strategy | Status |
+| ------- | ---------- | ------------------- | ------ |
+
+---
+
+## Release Readiness Checklist
+
+* [ ] All critical path tasks complete
+* [ ] All architecture components implemented
+* [ ] Security tasks complete
+* [ ] Observability integrated
+* [ ] Performance targets validated
+* [ ] Failure scenarios tested
+* [ ] Production readiness tasks complete
+* [ ] Documentation finalized
+
+---
+
+# 3️⃣ Individual Task Files (TASKS/TASK_XXX.md)
+
+Each task file must strictly follow:
+
+---
+
+# TASK_XXX: `<Title>`
+
+Status: 🔲 Not Started
+Phase: `<Phase Name>`
+Critical Path: Yes / No
+Parallelizable: Yes / No
+
+---
+
+## 1. Objective
+
+Clear statement of what this task achieves.
+
+---
+
+## 2. Architecture Mapping
+
+* Architecture Section:
+* Component:
+* PRD Section:
+
+---
+
+## 3. Detailed Description
+
+Concise but comprehensive explanation of the work.
+
+---
+
+## 4. Deliverables
+
+* Explicit artifacts
+* Modules
+* Configurations
+* Schemas
+* Documentation
+
+---
+
+## 5. Dependencies
+
+### Hard Dependencies
+
+(List blocking tasks)
+
+### Soft Dependencies
+
+(List related tasks)
+
+---
+
+## 6. Risks
+
+* Technical
+* Integration
+* Performance
+* Security
+
+---
+
+## 7. Acceptance Criteria
+
+Clear measurable validation conditions.
+
+---
+
+## 8. Validation Steps
+
+Step-by-step verification method to confirm correctness.
+
+---
+
+## 9. Definition of Done
+
+* Scope fully implemented
+* Integrated with related modules
+* Acceptance criteria satisfied
+* Reviewed
+* Documented
+* Tests (if applicable)
+* Checklist updated
+
+---
+
+## 10. Estimated Complexity
+
+S / M / L
+
+Estimated Effort Range: (e.g., 1–2 days)
+
+---
+
+## 11. Implementation Notes (To Be Filled During Execution)
+
+* Key decisions
+* Constraints encountered
+* Deviations (if approved)
+* Follow-up considerations
+
+---
+
+# FINAL INSTRUCTION
+
+Using the provided PRD and Architecture:
+
+Generate the full Tasks/ execution system.
+
+Ensure:
+
+* All architecture components are covered.
+* No dependency cycles exist.
+* Critical path is coherent.
+* Tasks are atomic and well-defined.
+* DEVELOPMENT_CHECKLIST is detailed enough to track progress granularly.
+* Each individual task file is complete and executable.
+
+This must feel like a real enterprise execution artifact suitable for long-term structured development.
+
+
+
+---