archwiki

Files (1)

• SKILL.md

SKILL.md (first lines)

# 4+1 Architecture Blueprint Wiki Generator

You are an expert software architect and technical writer. Your task is to analyze any codebase and generate a comprehensive architecture wiki using Philippe Kruchten's **"4+1" View Model of Software Architecture**. The output is a set of interconnected markdown documents saved to the `archwiki/` directory in the repository root.

## Background: The 4+1 View Model

The 4+1 model describes software architecture using five concurrent views, each addressing different stakeholder concerns:

| View | Stakeholders | Concerns | Components | Connectors |
|------|-------------|----------|------------|------------|
| **Logical** | End-user | Functionality | Classes, objects, packages | Association, inheritance, containment |
| **Process** | System integrator | Performance, scalability, fault-tolerance | Processes, tasks, threads | Messages, RPC, events, shared memory |
| **Development** | Programmers, managers | Organization, reuse, portability | Modules, subsystems, layers | Compilation dependencies, imports |
| **Physical** | System engineers | Deployment, topology, scalability | Nodes, containers, infrastructure | Network links, protocols |
| **Scenarios** | End-user, developer | Understandability, validation | Use cases, user stories | Interaction steps, scripts |

Scenarios (the "+1") tie all four views together and serve as both a driver for discovering architectural elements and a validation mechanism.

## Output Structure

Generate the following files in `./archwiki/`:

```
archwiki/
├── 0-Index.md                    # Table of contents and navigation
├── 1-Overview.md                 # Project overview and architecture summary
├── 2-Logical-View.md             # Object/class model, functional decomposition
├── 3-Process-View.md             # Concurrency, threading, runtime behavior
├── 4-Development-View.md         # Code organization, modules, layers, build
├── 5-Physical-View.md            # Deployment, infrastructure, hardware mapping
├── 6-Scenarios.md                # Key use cases tying all views together
├── 7-Architecture-Decisions.md   # Key design decisions and rationale
└── 8-Glossary.md                 # Terms, acronyms, definitions
```

## Workflow

### Phase 1: Project Discovery

**Objective**: Understand project structure, technology stack, and scope.

**Steps**:

1. **Get directory structure**:
```bash
find . -type f -not -path '*/.git/*' -not -path '*/node_modules/*' -not -path '*/target/*' -not -path '*/__pycache__/*' -not -path '*/dist/*' -not -path '*/build/*' -not -path '*/.next/*' -not -path '*/vendor/*' -not -path '*/.venv/*' -not -path '*/venv/*' | head -500
```

2. **Count files by type**:
```bash
find . -type f -not -path '*/.git/*' -not -path '*/node_modules/*' -not -path '*/target/*' -not -path '*/__pycache__/*' | sed 's/.*\.//' | sort | uniq -c | sort -rn | head -20
```

3. **Read key files** (in priority order):
   - README.md or README files
   - Package/build configs: `package.json`, `Cargo.toml`, `pyproject.toml`, `pom.xml`, `go.mod`, `build.gradle`, `Makefile`
   - Entry points: `main.*`, `index.*`, `app.*`, `server.*`, `lib.*`
   - Configuration: `docker-compose.yml`, `Dockerfile`, `*.config.*`, `.env.example`

4. **Identify technology stack**: Languages, frameworks, databases, external services

5. **Map core source directories**: Identify the main source code locations and their purpose

### Phase 2: Deep Code Analysis

**Objective**: Extract architectural elements for each of the 4+1 views.

**Steps**:

1. **Analyze imports and dependencies** across key source files to build a dependency graph
2. **Identify domain abstractions**: Core classes, interfaces, traits, types, data models
3. **Identify runtime behavior**: Entry points, event loops, background workers, queues, message handlers
4. **Map module/package boundaries**: How source code is organized into subsystems and layers
5. **Identify deployment artifacts**: Docker images, binaries, services, infrastructure config
6. **Extract key workflows**: Main user-facing operations, API endpoints, CLI commands

Read at least the top 20-30 most important source files. Prioritize:
- Files with many imports (central to the system)
- Entry point files
- Configuration and wiring files
- Core domain/business logic files
- API/interface definition files

### Phase 3: Document Generation

Generate each document following the templates below. Use **Mermaid diagrams** extensively.

### Phase 4: Quality Review

After generating all documents:
- Verify all Mermaid diagram syntax is valid
- Ensure cross-references between documents are correct
- Check that Scenarios reference elements from all four views
- Confirm no placeholder text remains

---

## Document Templates

### 0-Index.md

```markdown
# Architecture Blueprint: [Project Name]

> 4+1 Architectural View Model documentation generated from codebase analysis.

## About This Documentation

This architecture wiki documents **[Project Name]** using Philippe Kruchten's
4+1 View Model. Each view addresses different stakeholder concerns and together
they provide a complete picture of the system architecture.

## Navigation

| Document | View | Audience | Description |
|----------|------|----------|-------------|
| [1. Overview](1-Overview.md) | — | Everyone | Project purpose, tech stack, architecture summary |
| [2. Logical View](2-Logical-View.md) | Logical | End-users, analysts | Domain model, key abstractions, class relationships |
| [3. Process View](3-Process-View.md) | Process | Integrators | Concurrency, threads, runtime behavior, data flow |

From sathish316/skills, MIT.

More from sathish316/skills