# Implementation Guide - Architecture Gap Resolution
**Target:** v1.2.0 Production Release
**Timeline:** 4 Days
**Strategy:** 80/20 Pareto Principle
---
## Day 1: Marketplace Workspace Integration (P0-1)
### Goal
Fix ggen-marketplace compilation and re-enable in workspace
### Tasks
#### 1.1 Resolve Dependency Conflicts (2 hours)
```toml
# Cargo.toml - Fix base64 version conflict
[workspace.dependencies]
base64 = "0.22" # Force single version
# ggen-marketplace/Cargo.toml - Update dependencies
[dependencies]
base64 = { workspace = true }
reqwest = { version = "0.12", features = ["json"], default-features = false }
```
**Commands:**
```bash
# Check for version conflicts
cargo tree -d
# Force update
cargo update -p base64
# Verify
cargo check --package ggen-marketplace
```
#### 1.2 Fix libp2p Feature Flags (1 hour)
```toml
# ggen-marketplace/Cargo.toml
[dependencies]
libp2p = {
version = "0.56",
features = ["tcp", "noise", "yamux", "gossipsub", "kad", "identify"],
default-features = false,
optional = true
}
```
#### 1.3 Remove Workspace Exclusion (30 minutes)
```toml
# Cargo.toml:29 - DELETE THIS LINE
# exclude = ["ggen-marketplace"] # ← Remove this
# Keep only examples exclusion
exclude = [
"examples/rust-cli-lifecycle",
"examples/marketplace-demo/generated"
]
```
#### 1.4 Verify Compilation (30 minutes)
```bash
# Clean build
cargo clean
cargo check --workspace
# Should succeed now
cargo build --package ggen-marketplace
# Verify all features
cargo check --package ggen-marketplace --all-features
```
### Deliverable
✅ `ggen-marketplace` compiles with workspace
✅ No exclusion in Cargo.toml
✅ All dependency conflicts resolved
**Impact:** 25% of deployment readiness
---
## Day 2 (Morning): Fix Compilation Errors (P0-4)
### Goal
Eliminate all 23 workspace compilation errors
### Strategy
Systematic error fixing by priority
#### 2.1 Identify Error Categories (30 minutes)
```bash
# List all errors with details
# Categorize by crate
Expected categories:
- Type mismatches
- Missing imports
- Trait bound issues
- Lifetime errors
- Move semantics
#### 2.2 Fix by Crate Priority (2.5 hours)
**Priority Order:**
1. ggen-core (blocking everything)
2. cli (user-facing)
3. ggen-ai (AI features)
4. utils (supporting)
**Common fixes:**
```rust
// 1. Remove .unwrap() in production code
// ❌ BAD
let result = operation().unwrap();
// ✅ GOOD
let result = operation()
.map_err(|e| anyhow::anyhow!("Operation failed: {}", e))?;
// 2. Fix move semantics
// ❌ BAD
fn process(data: String) {
println!("{}", data);
// data moved here
}
let s = String::from("test");
process(s);
process(s); // ERROR: value used after move
// ✅ GOOD
fn process(data: &str) {
println!("{}", data);
}
let s = String::from("test");
process(&s);
process(&s); // OK
// 3. Fix trait bounds
// ❌ BAD
fn generic<T>(value: T) {
println!("{}", value); // ERROR: T doesn't impl Display
}
// ✅ GOOD
fn generic<T: std::fmt::Display>(value: T) {
println!("{}", value);
}
```
#### 2.3 Verify All Fixes (30 minutes)
```bash
# Must pass
cargo check --workspace
# Run tests
cargo test --workspace --lib
# Clippy
cargo clippy --workspace -- -D warnings
```
### Deliverable
✅ Zero compilation errors
✅ All tests pass
✅ Clippy clean
**Impact:** +15% (40% total)
---
## Day 2 (Afternoon): Mock Registry Foundation (P0-3 Start)
### Goal
Build in-memory mock marketplace registry
### Tasks
#### 2.4 Create Mock Registry (2 hours)
```rust
// ggen-marketplace/src/backend/mock.rs
use crate::error::Result;
use crate::models::{Package, PackageId, Query};
use crate::traits::Registry;
use async_trait::async_trait;
use std::collections::HashMap;
/// Mock in-memory registry for v1.2.0
///
/// Provides sample packages for testing and initial release.
/// Will be replaced with real P2P registry in v1.3.0.
pub struct MockRegistry {
packages: HashMap<String, Vec<Package>>,
}
impl MockRegistry {
pub fn new() -> Self {
let mut registry = Self {
packages: HashMap::new(),
};
registry.load_sample_packages();
registry
}
fn load_sample_packages(&mut self) {
// Rust packages
self.add_sample(Package {
id: PackageId::new("rust-axum-service"),
name: "rust-axum-service".to_string(),
version: "1.0.0".to_string(),
description: "Production-ready Axum web service template".to_string(),
categories: vec!["rust".to_string(), "web".to_string()],
..Default::default()
});
self.add_sample(Package {
id: PackageId::new("postgresql-database"),
name: "postgresql-database".to_string(),
version: "1.0.0".to_string(),
description: "PostgreSQL database with migrations".to_string(),
categories: vec!["database".to_string()],
..Default::default()
});
// Add 20+ more sample packages
// Categories: rust, web, database, frontend, backend, devops
}
fn add_sample(&mut self, package: Package) {
self.packages
.entry(package.name.clone())
.or_insert_with(Vec::new)
.push(package);
}
}
#[async_trait]
impl Registry for MockRegistry {
async fn search(&self, query: &Query) -> Result<Vec<Package>> {
let results: Vec<Package> = self
.packages
.values()
.flatten()
.filter(|pkg| {
pkg.name.contains(&query.text) ||
pkg.description.contains(&query.text) ||
pkg.categories.iter().any(|cat| query.text.contains(cat))
})
.cloned()
.collect();
Ok(results)
}
async fn get_package(&self, id: &PackageId) -> Result<Option<Package>> {
Ok(self.packages.get(&id.to_string())
.and_then(|versions| versions.first())
.cloned())
}
// Other methods return mock data or unimplemented!()
}
```
#### 2.5 Add Sample Package Database (1 hour)
```rust
// Create comprehensive sample packages
// Categories:
// - Rust: web services, CLI tools, libraries
// - Web: React, Vue, Next.js templates
// - Database: PostgreSQL, MySQL, MongoDB
// - DevOps: Docker, Kubernetes, CI/CD
// - Tools: testing, linting, formatting
// Aim for 30-50 sample packages
```
### Deliverable
✅ MockRegistry implementation
✅ 30+ sample packages
✅ Basic search working
**Impact:** Foundation for +20%
---
## Day 3: Complete Mock Marketplace (P0-3 Complete)
### Goal
Functional CLI commands with mock data
### Tasks
#### 3.1 Implement Package Installation (2 hours)
```rust
// ggen-marketplace/src/backend/mock.rs
impl MockRegistry {
pub async fn install_package(&self, id: &PackageId) -> Result<InstalledPackage> {
let package = self.get_package(id).await?
.ok_or_else(|| anyhow::anyhow!("Package not found"))?;
// Simulate installation
// 1. Create package directory
// 2. Copy template files
// 3. Update registry state
// 4. Return installation metadata
Ok(InstalledPackage {
package,
installed_at: chrono::Utc::now(),
location: PathBuf::from("~/.ggen/packages").join(&id.to_string()),
})
}
}
```
#### 3.2 CLI Integration (3 hours)
```rust
// cli/src/cmds/market/search.rs
use ggen_marketplace::backend::MockRegistry;
use ggen_marketplace::traits::Registry;
pub async fn search_command(query: String) -> anyhow::Result<()> {
let registry = MockRegistry::new();
println!("🔍 Searching marketplace for: {}", query);
let results = registry.search(&Query::new(&query)).await?;
if results.is_empty() {
println!("No packages found.");
return Ok(());
}
println!("\nFound {} packages:\n", results.len());
for pkg in results {
println!("📦 {} v{}", pkg.name, pkg.version);
println!(" {}", pkg.description);
println!(" Categories: {}", pkg.categories.join(", "));
println!();
}
Ok(())
}
// cli/src/cmds/market/add.rs
pub async fn add_command(package_name: String) -> anyhow::Result<()> {
let registry = MockRegistry::new();
println!("📦 Installing package: {}", package_name);
let package_id = PackageId::new(&package_name);
let installed = registry.install_package(&package_id).await?;
println!("✅ Installed {} v{}", installed.package.name, installed.package.version);
println!(" Location: {}", installed.location.display());
Ok(())
}
```
#### 3.3 Integration Tests (2 hours)
```rust
// cli/tests/market_integration.rs
#[tokio::test]
async fn test_market_search_command() {
let result = search_command("rust web".to_string()).await;
assert!(result.is_ok());
}
#[tokio::test]
async fn test_market_add_command() {
let result = add_command("rust-axum-service".to_string()).await;
assert!(result.is_ok());
}
#[tokio::test]
async fn test_end_to_end_workflow() {
// 1. Search for packages
let search_result = search_command("database".to_string()).await;
assert!(search_result.is_ok());
// 2. Install a package
let add_result = add_command("postgresql-database".to_string()).await;
assert!(add_result.is_ok());
// 3. Verify installation
let registry = MockRegistry::new();
let installed = registry.get_package(&PackageId::new("postgresql-database")).await;
assert!(installed.is_ok());
}
```
### Deliverable
✅ `ggen market search` works
✅ `ggen market add` works
✅ `ggen market list` works
✅ Integration tests pass
**Impact:** +20% (60% total)
---
## Day 4: Validation & Release (P0-2)
### Goal
Production validation and v1.2.0 release
### Tasks
#### 4.1 Lifecycle Command Validation (2 hours)
```bash
# Test all lifecycle commands
ggen lifecycle list
ggen lifecycle run init
ggen lifecycle run build
ggen lifecycle run test
ggen lifecycle run deploy
# Verify make.toml parsing
cd examples/rust-cli-lifecycle
ggen lifecycle list # Should show custom phases
# Test hooks
ggen lifecycle run build --verbose # Should show hook execution
```
#### 4.2 End-to-End Testing (3 hours)
```bash
# Full workflow test
mkdir test-project
cd test-project
# 1. Initialize project
ggen lifecycle run init
# 2. Search marketplace
ggen market search "rust web"
# 3. Add packages
ggen market add rust-axum-service
ggen market add postgresql-database
# 4. Generate code
ggen template generate rust-axum-service:api.tmpl
# 5. Build and test
ggen lifecycle run build
ggen lifecycle run test
# 6. Production validation
ggen lifecycle readiness
ggen lifecycle validate --env production
# All should work!
```
#### 4.3 Production Validation (1 hour)
```bash
# Run production validation suite
cargo test --package ggen-core --test production_validation
# Check readiness score
ggen lifecycle readiness
# Expected: 90%+ score
# Verify deployment readiness
ggen lifecycle validate --env production
# Expected: ✅ DEPLOYMENT READY
```
#### 4.4 Documentation & Release (2 hours)
1. Update CHANGELOG.md
2. Update README.md with v1.2.0 features
3. Update docs/cli.md with marketplace commands
4. Create release notes
5. Tag release: `git tag v1.2.0`
6. Cargo publish dry-run: `cargo publish --dry-run`
7. Final release: `cargo publish`
### Deliverable
✅ All tests pass (100%)
✅ Production readiness: 90%+
✅ Documentation updated
✅ v1.2.0 released
**Impact:** +20% (80% total)
---
## Success Criteria
### Must Have (v1.2.0)
- [x] ggen-marketplace compiled and integrated
- [x] Zero compilation errors
- [x] Mock marketplace with 30+ packages
- [x] CLI commands working (search, add, list)
- [x] Lifecycle commands validated
- [x] Production readiness: 90%+
- [x] Cargo publish succeeds
### Nice to Have (Defer to v1.3.0)
- [ ] P2P package distribution
- [ ] Cryptographic signing
- [ ] Full-text search (Tantivy)
- [ ] GraphQL API server
### Future (v1.4.0+)
- [ ] WASM plugin system
- [ ] ML recommendations
- [ ] Framework adapters
- [ ] Performance monitoring
---
## Risk Mitigation
### High Risk: Dependency Conflicts (Day 1)
**Mitigation:**
- Use workspace dependencies
- Pin versions explicitly
- Test with `cargo tree -d`
### Medium Risk: Integration Issues (Day 3)
**Mitigation:**
- Mock data for testing
- Comprehensive integration tests
- Fallback to simpler implementations
### Low Risk: Time Overrun
**Mitigation:**
- 80/20 focus on critical features
- Defer P1/P2 to future versions
- Clear scope boundaries
---
## Team Assignments
### Developer 1 (Backend)
- Day 1: Marketplace integration
- Day 2: Compilation fixes
- Day 3: Mock registry implementation
### Developer 2 (CLI)
- Day 2: CLI scaffolding
- Day 3: Command implementation
- Day 4: Integration testing
### Developer 3 (QA/Docs)
- Day 3: Integration tests
- Day 4: End-to-end validation
- Day 4: Documentation updates
---
## Post-Release (v1.3.0 Planning)
### Week 1-2: P2P Foundation
- Enable libp2p features
- Test peer discovery locally
- Implement Kademlia DHT integration
### Week 3: Cryptography & Search
- Add Ed25519 signing CLI
- Build Tantivy search index
- Integration testing
### Week 4: Release v1.3.0
- Documentation
- Migration guide
- Community announcement
---
## Metrics Dashboard
Track daily progress:
```
Day 1:
- Compilation errors: 23 → 0 ✅
- Marketplace status: Excluded → Integrated ✅
- Completion: 72% → 82% ✅
Day 2:
- Mock registry: 0% → 50% ✅
- Sample packages: 0 → 30 ✅
- Completion: 82% → 87% ✅
Day 3:
- CLI commands: 0% → 100% ✅
- Integration tests: 0% → 100% ✅
- Completion: 87% → 92% ✅
Day 4:
- Production validation: 90% → 95% ✅
- Release status: Not ready → Ready ✅
- Completion: 92% → 100% ✅
```
---
## Final Checklist
Before cargo publish:
- [ ] All tests pass (`cargo test --workspace`)
- [ ] Clippy clean (`cargo clippy --workspace -- -D warnings`)
- [ ] Documentation complete (`cargo doc --no-deps`)
- [ ] CHANGELOG.md updated
- [ ] Version bumped to 1.2.0 (all Cargo.toml)
- [ ] Git tag created (`git tag v1.2.0`)
- [ ] Dry-run succeeds (`cargo publish --dry-run`)
- [ ] Production validation passes (`ggen lifecycle readiness`)
---
**Guide Complete. Ready for 4-day sprint!**