Setup template repository structure with CI/CD workflows and documentation

- Add directory structure (src/, include/, tests/, docs/, .github/workflows/)
- Add C++ CI workflow with clang-format and cppcheck
- Add Rust CI workflow with cargo clippy
- Add C CI workflow with clang-format and cppcheck
- Add README.md template with standard structure
- Add CONTRIBUTING.md with step-by-step PR guidelines

Author: mohitmishra786

.github/workflows/c-ci.yml

@@ -0,0 +1,26 @@
+name: C CI
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  lint-and-check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Run clang-format check
+        uses: jidicula/clang-format-action@v4.11.0
+        with:
+          clang-format-version: '15'
+          check-path: 'src'
+
+      - name: Install cppcheck
+        run: sudo apt-get update && sudo apt-get install -y cppcheck
+
+      - name: Run cppcheck
+        run: |
+          cppcheck --enable=all --error-exitcode=1 --suppress=missingIncludeSystem --language=c src/ include/

CONTRIBUTING.md

@@ -0,0 +1,49 @@
+# Contributing Guide
+
+Thank you for your interest in contributing! This guide outlines our step-by-step PR process to ensure code quality and maintainability.
+
+## Step-by-Step PR Logic
+
+We follow an **atomic commit** approach where each PR should build the system incrementally, one logical step at a time. This makes code review easier and preserves the educational value of seeing how the system was constructed.
+
+### Commit Structure
+
+A single PR should **not** be a "code dump." Instead, break your implementation into logical commits:
+
+#### Commit 1: Define Interfaces and Data Structures
+- Add header files (`include/`)
+- Define function signatures
+- Define data structures and their relationships
+- Document the API contract
+
+#### Commit 2: Implement Core Logic
+- Implement the main algorithms
+- Add the primary business logic (e.g., hash table operations, network loop, memory allocator)
+- Focus on correctness first
+
+#### Commit 3: Add Tests and Documentation
+- Write unit tests (`tests/`)
+- Add integration tests if applicable
+- Update documentation (`docs/`)
+- Ensure all tests pass
+
+### Linear History
+
+We prefer **merge commits** or **rebase-merges** to preserve the step-by-step history of how the system was built. This allows future contributors to understand the evolution of the codebase.
+
+### Before Submitting
+
+- [ ] All commits follow the atomic structure above
+- [ ] Code passes all CI checks (formatting, static analysis, tests)
+- [ ] Documentation is updated
+- [ ] Tests are added and passing
+- [ ] PR description explains the changes and rationale
+
+### CI Requirements
+
+All PRs must pass:
+- Code formatting checks (clang-format for C/C++, rustfmt for Rust)
+- Static analysis (cppcheck for C/C++, clippy for Rust)
+- All tests must pass
+
+These checks are enforced via branch protection rules on `main`.

README.md

@@ -0,0 +1,61 @@
+# [System Name]
+
+[Brief 1-sentence summary of what this system does.]
+
+## Architecture Overview
+
+[High-level description of the system components. Explain the main modules, their responsibilities, and how they interact with each other.]
+
+## Memory Layout
+
+[This is a mandatory section. Use a text-based diagram (ASCII) to show:
+- Pointer relationships
+- Data structure padding
+- Segment usage (stack, heap, etc.)
+- Memory alignment considerations
+
+Example format:
+```
++------------------+
+| Stack Frame      |
+| - local vars     |
+| - return addr    |
++------------------+
+| Heap             |
+| - malloc'd data  |
++------------------+
+```
+]
+
+## How it Works
+
+[Step-by-step walkthrough of the primary logic flow. For example:
+- "From Socket Listen to Request Handle"
+- "From Input Parsing to Output Generation"
+- "From Memory Allocation to Deallocation"
+
+Break down the flow into clear, numbered steps that explain the educational core of the system.]
+
+## Build Instructions
+
+[Direct shell commands to compile and run the system.]
+
+```bash
+# Compile
+[command here]
+
+# Run
+[command here]
+
+# Run tests
+[command here]
+```
+
+## Comparison
+
+[If applicable, explain how this implementation differs from its Rust counterpart (or other language implementations). Discuss:
+- Memory safety approaches
+- Performance characteristics
+- Error handling strategies
+- Code organization differences
+]