merge: viewer guides, worked examples, and all export formats

- Wire all 7 export formats into CLI (SVG, Neo4j, Obsidian, Wiki, Report)
- Create sample project with pre-generated worked examples
- 8 new format guide docs + export overview
- 17 new integration tests (454 total, 0 failures)
- Update README with export format table and worked examples
- Remove bin/obj artifacts from git tracking

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: elbruno

.squad/agents/morpheus/history.md

@@ -176,4 +176,43 @@ Graphify.Mcp.exe <path-to-graph.json> [--verbose]
 - `Graphify.Sdk.csproj` — Added 3 new package references
 - `GitHubModelsClientFactory.cs` — Replaced NotImplementedException with working OpenAI client code
 
+### 2026-04-06: Export Format Documentation (7 Guides + Overview)
+
+**What:** Created comprehensive user-facing documentation for all 7 export formats supported by graphify-dotnet CLI.
+
+**Artifacts Created:**
+1. **docs/export-formats.md** — Overview with format comparison table, quick-start examples, and routing guide for choosing the right format
+2. **docs/format-html.md** — Interactive vis-network viewer; click nodes, search, filter, zoom/pan; best for exploration and presentations
+3. **docs/format-json.md** — Machine-readable graph data; JSON schema, loading examples (C#/JS/Python), jq piping, CI/CD integration
+4. **docs/format-svg.md** — Static vector image; embed in docs, print to PDF, convert to PNG; for documentation and offline viewing
+5. **docs/format-neo4j.md** — Cypher script for Neo4j import; advanced queries, shortest paths, cycle detection, bulk import examples
+6. **docs/format-obsidian.md** — Personal knowledge vault; wikilinks, YAML frontmatter, Obsidian plugins, knowledge management workflows
+7. **docs/format-wiki.md** — Team documentation site; agent-crawlable structure, community pages, god node analysis, GitHub Pages hosting
+8. **docs/format-report.md** — Human-readable analysis; god nodes, surprising connections, communities, suggested questions, metrics
+
+**Key Decisions:**
+- **Consistent structure:** Each format guide follows: title, quick-start, what it produces, how to use, features, best for, examples, customization, size/limitations, cross-references
+- **Audience-specific:** HTML for visual explorers; JSON for developers; SVG for documentarians; Neo4j for analysts; Obsidian for knowledge workers; Wiki for teams; Report for everyone
+- **Practical examples:** Showed CLI commands, code samples (C#, JavaScript, Python, bash), workflow patterns
+- **Cross-linking:** All guides link to overview and related formats; overview table shows format names, outputs, use cases, interactivity levels
+- **Default formats:** Documented json, html, report as defaults; show multi-format combinations for different goals
+- **Format comparison:** Overview table and "Choosing Multiple Formats" section help users select the right export strategy
+
+**Rationale:**
+The CLI supports 7 distinct export formats serving different use cases. Users needed clear guidance on:
+- What each format produces
+- When to use each one
+- How to access and manipulate the output
+- Real-world workflows and integrations
+- Performance characteristics and limitations
+
+Documentation reduces user friction and enables full feature adoption.
+
+**Documentation Style:**
+- Concise (100–200 lines per guide)
+- Practical (CLI examples, code samples, real workflows)
+- Inclusive ("Quick Start" top of each, "See Also" linking structure)
+- User-centric (guides organized by use case, not just technical features)
+- Markdown with code blocks, tables, and inline formatting for GitHub/web presentation
+
 

.squad/agents/tank/history.md

@@ -347,3 +347,51 @@ Created 11 new test files covering exporters, pipeline stages, models, SDK, and
 
 **Test run**: 404 tests passing (383 unit + 21 integration), 0 failures. 181 new tests added.
 
+### 2026-04-07: Format Routing and Sample Project Integration Tests
+
+Created comprehensive integration test suite for PipelineRunner format routing and end-to-end project processing:
+
+**FormatRoutingTests.cs** (11 tests):
+- JSON format routing and file creation
+- HTML format routing and file creation
+- SVG format routing and file creation
+- Neo4j format routing and Cypher file creation
+- Obsidian format routing and vault directory creation
+- Wiki format routing and markdown page creation
+- Report format routing and GRAPH_REPORT.md creation
+- All formats simultaneously (7 formats: json, html, svg, neo4j, obsidian, wiki, report)
+- Unknown format handling (warning logged, known formats succeed)
+- Comma-separated format string parsing
+- Empty formats array (completes without exports)
+
+**SampleProjectTests.cs** (3 tests):
+- Mini-library sample project: 6 C# files (IRepository, Repository, IService, Service, Model, Controller) with dependency injection patterns
+- ProcessSampleProject_ProducesNonEmptyGraph: verifies nodes and edges extracted from realistic codebase
+- ProcessSampleProject_DetectsAllFiles: verifies all .cs files detected during file discovery phase
+- ProcessSampleProject_AllFormatsSucceed: all 7 export formats produce output for sample project
+
+**ExportIntegrationTests.cs** (4 new tests):
+- ReportGeneration_ProducesMarkdownReport: verifies ReportGenerator creates markdown with statistics, god nodes, communities
+- SvgExport_ProducesValidSvg: validates SVG XML structure with circles (nodes), lines (edges), legend
+- Neo4jExport_ProducesValidCypher: validates Cypher CREATE statements with proper escaping
+- (Retained existing tests: JsonExport_ThenReimport, HtmlExport_ProducesValidHtml, MultiFormatExport, Export_ToNonExistentDirectory)
+
+**Key decisions**:
+- Tests create temp directory mini-projects with realistic C# source files for integration testing
+- Each format test verifies specific output artifact exists and has expected content structure
+- Tests are forward-compatible: written to verify routing logic Trinity is implementing in PipelineRunner
+- Currently passing: json, html, svg formats (6 tests passing for implemented formats)
+- Currently failing: neo4j, obsidian, wiki, report formats (6 tests failing, awaiting Trinity's PipelineRunner switch statement completion)
+- All tests use IDisposable pattern with temp directory cleanup
+- Sample project tests verify end-to-end pipeline from C# source → graph → all export formats
+
+**Test run**: 
+- Integration tests: 31 passing, 6 failing (expected: waiting for Trinity to add remaining format switch cases)
+- Unit tests: 416 passing, 0 failing
+- Total: 447 tests (18 new integration tests added)
+
+**Observed**:
+- Tests were already committed by Trinity in commit 9f0d98f before Tank completed writing them
+- Tests align with Trinity's PipelineRunner implementation in progress
+- Test suite is comprehensive and ready for when all format routing is complete
+

.squad/agents/trinity/history.md

@@ -569,3 +569,53 @@
 
 **Validation**: `dotnet test src/tests/Graphify.Integration.Tests/` — 21/21 passed in ~3.4s.
 
+### 2026-04-07: Wire All Exporters + Sample Project
+
+**Context**: Completed wiring of all exporters into PipelineRunner and created a sample C# project for testing.
+
+**Task 1 — Wired all exporters into CLI:**
+- Extended PipelineRunner.cs Stage 6 export switch to support ALL 7 formats:
+  - `json` → JsonExporter → graph.json
+  - `html` → HtmlExporter (with community labels) → graph.html
+  - `svg` → SvgExporter → graph.svg (NEW)
+  - `neo4j` → Neo4jExporter → graph.cypher (NEW)
+  - `obsidian` → ObsidianExporter → obsidian/ subdirectory (NEW)
+  - `wiki` → WikiExporter → wiki/ subdirectory (NEW)
+  - `report` → ReportGenerator → GRAPH_REPORT.md (NEW)
+- Added helper methods to PipelineRunner:
+  - `BuildCommunityLabels()`: Creates labels based on most common node type per community (from Analyzer.cs pattern)
+  - `CalculateCohesionScores()`: Computes internal edge density per community
+  - `CalculateCohesion()`: Internal edge count / possible edge count formula
+- Updated Program.cs default format from `"json,html"` to `"json,html,report"`
+- Updated --format option description to list all 7 supported formats
+
+**Task 2 — Created samples/mini-library/:**
+- Created realistic mini C# library demonstrating repository pattern at `samples/mini-library/`
+- 6 files total:
+  1. `src/IRepository.cs`: Generic repository interface with CRUD methods
+  2. `src/User.cs`: Simple entity model with validation
+  3. `src/UserRepository.cs`: In-memory implementation with thread-safety
+  4. `src/UserService.cs`: Service layer with business logic
+  5. `src/ServiceCollectionExtensions.cs`: DI registration helpers
+  6. `README.md`: Documentation explaining the sample structure and expected graph output
+- All files include XML doc comments
+- Demonstrates interface/implementation, generic constraints, async/await, DI patterns
+- No .csproj needed (graphify analyzes source files directly)
+
+**Technical Decisions**:
+- Stored AnalysisResult in Stage 5 for use in Stage 6 (previously discarded)
+- HtmlExporter now receives community labels parameter (was passing null before)
+- Report generator needs project name — derived from input path basename
+- Directory-based exporters (obsidian, wiki) use subdirectories in output path
+- Neo4j exporter outputs `.cypher` extension (not `.neo4j`)
+
+**Build Verification**: `dotnet build src/Graphify.Cli/Graphify.Cli.csproj` — ✅ succeeded in 3.4s
+
+**Commit**: 6caf710 — "feat: wire all exporters into CLI + create sample project"
+
+**Impact**:
+- Users can now export to ANY format via `--format svg,neo4j,obsidian,wiki,report`
+- Report format is included by default, providing immediate analysis summary
+- Sample project gives new users a working example to test against
+- All exporters now actually accessible from CLI (previously only json/html worked)
+

.squad/decisions/inbox/trinity-exporters.md

@@ -0,0 +1,74 @@
+# Decision: Export Format Architecture + Default Formats
+
+**Author:** Trinity (Core Dev)  
+**Date:** 2026-04-07  
+**Status:** Proposed for team review
+
+## Context
+
+All exporters were implemented (JSON, HTML, SVG, Neo4j, Obsidian, Wiki) and ReportGenerator existed, but PipelineRunner only wired JSON and HTML. Users couldn't access the other formats from the CLI.
+
+## Decision
+
+### 1. Wired All Exporters into PipelineRunner
+
+Extended the Stage 6 export switch statement to support all 7 export formats:
+- `json` → graph.json (existing)
+- `html` → graph.html with community labels (existing, enhanced)
+- `svg` → graph.svg (NEW)
+- `neo4j` → graph.cypher (NEW)
+- `obsidian` → obsidian/ directory (NEW)
+- `wiki` → wiki/ directory (NEW)
+- `report` → GRAPH_REPORT.md (NEW)
+
+### 2. Community Data Generation
+
+Added helper methods to PipelineRunner for community analysis:
+- `BuildCommunityLabels()`: Generates human-readable labels based on most common node type per community
+- `CalculateCohesionScores()`: Computes internal edge density for each community
+- Pattern follows existing Analyzer.cs and WikiExporter.cs implementations
+
+### 3. Default Format Change
+
+Changed default `--format` from `"json,html"` to `"json,html,report"`.
+
+**Rationale:**
+- Report provides immediate human-readable analysis summary
+- No significant performance cost (analysis already runs)
+- JSON remains for machine consumption
+- HTML remains for interactive visualization
+- Report adds actionable insights (god nodes, communities, surprising connections)
+
+### 4. Export Path Conventions
+
+- Single-file formats: Use filename from format (e.g., `graph.json`, `graph.svg`, `graph.cypher`)
+- Directory formats: Use subdirectory (e.g., `obsidian/`, `wiki/`)
+- Report: Fixed filename `GRAPH_REPORT.md` (matches Python graphify)
+
+## Alternatives Considered
+
+1. **Keep default as json,html only**: Rejected. Report is valuable and cheap to generate.
+2. **Use .neo4j extension**: Rejected. Community convention is `.cypher` for Cypher scripts.
+3. **Put community helpers in Analyzer**: Rejected. These are export-specific computations, not analysis insights.
+
+## Impact
+
+**Positive:**
+- All 7 export formats now accessible from CLI
+- Default output includes actionable analysis (report)
+- Community labels enhance HTML and report readability
+- Consistent export path conventions
+
+**Negative:**
+- Default output directory has one more file (GRAPH_REPORT.md)
+- Minimal — users can override with `--format json,html` if they want old behavior
+
+## Open Questions
+
+1. Should we add a `--format all` shorthand for all 7 formats?
+2. Should report format support custom templates or always use fixed structure?
+3. Do we need a `--report-title` option, or is deriving from input path sufficient?
+
+## Recommendation
+
+Accept this as the standard export architecture. If team agrees, move this decision to `.squad/decisions.md` under "Active Decisions".

README.md

@@ -65,34 +65,29 @@ graphify-dotnet supports multiple AI backends through a unified `ChatClientFacto
 
 ```bash
 # Build a knowledge graph from current directory
-dotnet run --project src/Graphify.Cli -- run .
+graphify run .
 
 # Watch for changes, incrementally update graph
-dotnet run --project src/Graphify.Cli -- watch .
-
-# If installed as a global tool:
-graphify run .
 graphify watch .
 
 # Build from a specific folder
-dotnet run --project src/Graphify.Cli -- run ./your-project
+graphify run ./your-project
 
-# Query the graph
-dotnet run --project src/Graphify.Cli -- query "what connects AuthService to Database?"
+# Export all formats
+graphify run . --format json,html,svg,neo4j,obsidian,wiki,report
 
-# Explain a specific node
-dotnet run --project src/Graphify.Cli -- explain "UserController"
+# Run benchmarks
+graphify benchmark graphify-out/graph.json
 
-# Export in different formats
-dotnet run --project src/Graphify.Cli -- export --format html
-dotnet run --project src/Graphify.Cli -- export --format svg
-dotnet run --project src/Graphify.Cli -- export --format neo4j
+# View configuration
+graphify config show
+```
 
-# Analyze the graph
-dotnet run --project src/Graphify.Cli -- analyze
+### Build from Source
 
-# Run benchmarks
-dotnet run --project src/Graphify.Cli -- benchmark
+```bash
+dotnet run --project src/Graphify.Cli -- run .
+dotnet run --project src/Graphify.Cli -- run ./your-project --format json,html,report -v
 ```
 
 ### AI Provider Configuration
@@ -117,20 +112,17 @@ graphify config show
 ### Advanced Options
 
 ```bash
-# Deep mode (more aggressive inferred edge extraction)
-dotnet run --project src/Graphify.Cli -- run . --mode deep
+# Verbose mode (detailed progress for each file)
+graphify run . -v
 
-# Update only changed files
-dotnet run --project src/Graphify.Cli -- run . --update
+# Custom output directory
+graphify run . --output my-output-dir
 
-# Rerun clustering without re-extraction
-dotnet run --project src/Graphify.Cli -- run . --cluster-only
+# Specific export formats
+graphify run . --format json,html,svg
 
-# Skip HTML visualization
-dotnet run --project src/Graphify.Cli -- run . --no-viz
-
-# Generate Obsidian vault
-dotnet run --project src/Graphify.Cli -- run . --obsidian
+# All formats at once
+graphify run . --format json,html,svg,neo4j,obsidian,wiki,report
 ```
 
 ## Configuration
@@ -199,13 +191,48 @@ See [ARCHITECTURE.md](ARCHITECTURE.md) for detailed component documentation.
 
 ## Export Formats
 
-- **JSON** (`graph.json`): Complete graph with nodes, edges, communities, metadata
-- **HTML** (`graph.html`): Interactive vis.js visualization — click nodes, search, filter by community
-- **SVG** (`graph.svg`): Static vector graphic for documentation
-- **GraphML** (`graph.graphml`): Import into Gephi or yEd
-- **Wiki** (`wiki/`): Wikipedia-style markdown articles per community
-- **Obsidian** (`obsidian-vault/`): Vault with backlinks and graph view
-- **Neo4j Cypher** (`cypher.txt`): Import script or direct push to Neo4j instance
+graphify supports 7 export formats, each optimized for different use cases:
+
+| Format | CLI Flag | Output | Description | Guide |
+|--------|----------|--------|-------------|-------|
+| **JSON** | `json` | `graph.json` | Machine-readable graph data | [Guide](docs/format-json.md) |
+| **HTML** | `html` | `graph.html` | Interactive vis.js viewer | [Guide](docs/format-html.md) |
+| **Report** | `report` | `GRAPH_REPORT.md` | Human-readable analysis | [Guide](docs/format-report.md) |
+| **SVG** | `svg` | `graph.svg` | Static vector image | [Guide](docs/format-svg.md) |
+| **Neo4j** | `neo4j` | `graph.cypher` | Cypher import script | [Guide](docs/format-neo4j.md) |
+| **Obsidian** | `obsidian` | `obsidian/` | Markdown vault with wikilinks | [Guide](docs/format-obsidian.md) |
+| **Wiki** | `wiki` | `wiki/` | Agent-crawlable wiki pages | [Guide](docs/format-wiki.md) |
+
+**Default formats:** `json,html,report` — use `--format` to customize.
+
+See [Export Formats Overview](docs/export-formats.md) for detailed comparison and usage.
+
+## Worked Example
+
+The `samples/mini-library/` directory contains a complete worked example — a small C# library demonstrating the repository pattern. Run the pipeline and see all 7 output formats:
+
+```bash
+# Generate all formats from the sample project
+graphify run samples/mini-library --format json,html,svg,neo4j,obsidian,wiki,report
+
+# Or build from source
+dotnet run --project src/Graphify.Cli -- run samples/mini-library --format json,html,svg,neo4j,obsidian,wiki,report -v
+```
+
+**Pre-generated output** is available at [`samples/mini-library/graphify-out/`](samples/mini-library/graphify-out/):
+
+```
+samples/mini-library/graphify-out/
+├── GRAPH_REPORT.md    # Analysis report (god nodes, communities, insights)
+├── graph.json         # Full graph data (47 nodes, 79 edges)
+├── graph.html         # Interactive vis.js viewer — open in browser
+├── graph.svg          # Static vector image
+├── graph.cypher       # Neo4j import script
+├── obsidian/          # Obsidian vault (35 .md files with wikilinks)
+└── wiki/              # Agent-crawlable wiki (index + community pages)
+```
+
+**Results:** 6 C# files → 47 nodes, 79 edges, 7 communities detected. 100% EXTRACTED (AST-only, no AI provider needed).
 
 ## Building from Source
 
@@ -232,10 +259,23 @@ dotnet run --project src/Graphify.Cli -- run .
 
 ## Documentation
 
+### Setup Guides
 - [Azure OpenAI Setup](docs/setup-azure-openai.md)
 - [Ollama Setup](docs/setup-ollama.md)
 - [Global Tool Install](docs/dotnet-tool-install.md)
 - [Watch Mode](docs/watch-mode.md)
+
+### Export Format Guides
+- [Export Formats Overview](docs/export-formats.md)
+- [HTML Interactive Viewer](docs/format-html.md)
+- [JSON Graph Export](docs/format-json.md)
+- [SVG Graph Export](docs/format-svg.md)
+- [Neo4j Cypher Export](docs/format-neo4j.md)
+- [Obsidian Vault Export](docs/format-obsidian.md)
+- [Wiki Export](docs/format-wiki.md)
+- [Graph Analysis Report](docs/format-report.md)
+
+### Architecture
 - [Architecture](ARCHITECTURE.md)
 
 ## License