Creating New Projects

Start a new project from scratch with DevOpsMaestro and get a fully-configured development environment instantly.

---

Overview

When starting a new project with DevOpsMaestro:

1. Create your project directory - Standard app setup
2. Initialize your codebase - git, language setup, dependencies
3. Add to DevOpsMaestro - Track with the hierarchy
4. Build & develop - Start coding in a containerized environment

The key advantage: DevOpsMaestro gives you a production-ready development environment from day one, with LSP servers, debuggers, linters, and Neovim configured automatically.

---

Language-Specific Quickstarts

Go API Project

Perfect for REST APIs, CLI tools, or microservices:

# 1. Create project directory
mkdir ~/Developer/go-user-api
cd ~/Developer/go-user-api

# 2. Initialize Go module
go mod init github.com/yourorg/go-user-api

# 3. Create your application source files
# (add your own main.go here)

# 4. Add to DevOpsMaestro
dvm admin init  # Only needed once per machine
dvm create ecosystem mycompany
dvm create domain backend-services  
dvm create app go-user-api --from-cwd --description "User management API"
dvm create workspace dev

# 5. Build and develop
dvm build
dvm attach

# Inside container:
# go run main.go &
# curl http://localhost:8080/users
# nvim main.go  # Fully configured with LSP, syntax highlighting, and more!

What you get: - Go 1.25+ with all standard tools - gopls LSP server for autocompletion, error detection
- dlv debugger pre-configured - Pre-configured Neovim with lazyvim structure and "core" plugin package: - Syntax highlighting (treesitter) - Fuzzy file finder (telescope) - LSP support with autocompletion - Git integration - Keybinding help system - Air for hot reloading (if you add it to go.mod)

Python FastAPI Project

Perfect for web APIs and data science services:

# 1. Create project directory
mkdir ~/Developer/python-fastapi-app
cd ~/Developer/python-fastapi-app

# 2. Initialize Python project
cat > requirements.txt << 'EOF'
fastapi>=0.100.0
uvicorn[standard]>=0.23.0
pydantic>=2.0.0
EOF

# 3. Create your application source files
# (add your own main.py here)

# 3. Add to DevOpsMaestro
dvm admin init  # Only needed once
dvm create ecosystem personal
dvm create domain webapps
dvm create app python-fastapi-app --from-cwd --description "FastAPI web service"
dvm create workspace dev

# 4. Build and develop
dvm build
dvm attach

# Inside container:
# pip install -r requirements.txt
# python main.py &
# curl http://localhost:8000/users
# nvim main.py  # Fully configured IDE experience!

What you get: - Python 3.12+ with pip and venv - pylsp (Python LSP Server) for autocompletion - black formatter and flake8 linter - Pre-configured Neovim with essential IDE features: - Python syntax highlighting and treesitter - LSP autocompletion and error detection - Fuzzy file/content search - Git integration and status - FastAPI development server with auto-reload

Node.js/TypeScript Project

Perfect for web applications and APIs:

# 1. Create project directory
mkdir ~/Developer/node-typescript-api
cd ~/Developer/node-typescript-api

# 2. Initialize Node.js project
npm init -y
npm install express @types/express typescript ts-node nodemon
npm install --save-dev @types/node

# 3. Setup TypeScript
cat > tsconfig.json << 'EOF'
{
  "compilerOptions": {
    "target": "ES2022",
    "module": "commonjs",
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "dist"]
}
EOF

# 4. Create source structure
mkdir src
# (add your own src/app.ts here)

# 5. Update package.json scripts
npm pkg set scripts.start="node dist/app.js"
npm pkg set scripts.dev="nodemon --exec ts-node src/app.ts"
npm pkg set scripts.build="tsc"

# 6. Add to DevOpsMaestro
dvm admin init
dvm create ecosystem personal  
dvm create domain webapps
dvm create app node-typescript-api --from-cwd --description "TypeScript Express API"
dvm create workspace dev

# 7. Build and develop
dvm build
dvm attach

# Inside container:
# npm run dev &
# curl http://localhost:3000/users  
# nvim src/app.ts  # Complete TypeScript development environment!

What you get: - Node.js 20+ with npm - TypeScript compiler and typescript-language-server - ESLint and Prettier pre-configured - Complete Neovim IDE with default configuration: - TypeScript syntax highlighting and intelligence - LSP autocompletion and error detection - File navigation and fuzzy finding - Git integration and blame - Hot reloading with nodemon

Rust CLI Project

Perfect for system tools and high-performance applications:

# 1. Create project with Cargo
cargo new --bin rust-cli-tool
cd rust-cli-tool

# 2. Add dependencies
cat >> Cargo.toml << 'EOF'

[dependencies]
clap = { version = "4.4", features = ["derive"] }
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
tokio = { version = "1.0", features = ["full"] }
EOF

# 3. Create your application source files
# (add your own src/main.rs here — cargo new already created a starter)

# 4. Add to DevOpsMaestro
dvm admin init
dvm create ecosystem personal
dvm create domain systems
dvm create app rust-cli-tool --from-cwd --description "High-performance CLI tool"
dvm create workspace dev

# 5. Build and develop
dvm build  
dvm attach

# Inside container:
# cargo run -- info
# cargo run -- config --format json
# nvim src/main.rs  # Professional Rust development setup!

What you get: - Rust stable with Cargo - rust-analyzer LSP server for autocompletion and error detection - rustfmt formatter and Clippy linter - Professional Neovim setup with IDE-quality features: - Rust syntax highlighting with treesitter - LSP autocompletion and inline diagnostics - Project-wide fuzzy search and navigation - Git integration and change tracking - Debug symbols enabled for gdb/lldb debugging

---

Project Templates (Future Feature)

Coming in v0.13.0

Project templates will allow you to scaffold new projects with pre-configured setups:

# Future syntax
dvm create project my-api --template go-rest-api
dvm create project my-app --template python-fastapi  
dvm create project my-tool --template rust-cli
dvm create project my-web --template nextjs-app

Templates will include: - Language-specific starter code - Best practice project structure
- CI/CD pipeline configurations - Testing frameworks pre-configured - Documentation templates

---

Advanced Project Setups

Microservices Project (Multiple Apps)

Set up multiple related services:

# 1. Create ecosystem and domain
dvm create ecosystem ecommerce
dvm create domain backend-services

# 2. Create multiple apps
mkdir ~/Developer/ecommerce && cd ~/Developer/ecommerce

# User service
mkdir user-service && cd user-service
go mod init github.com/ecommerce/user-service
echo 'package main\n\nfunc main() { println("User Service") }' > main.go
dvm create app user-service --from-cwd --description "User management service"
dvm create workspace dev

# Product service  
cd .. && mkdir product-service && cd product-service
go mod init github.com/ecommerce/product-service
echo 'package main\n\nfunc main() { println("Product Service") }' > main.go
dvm create app product-service --from-cwd --description "Product catalog service"
dvm create workspace dev

# Order service
cd .. && mkdir order-service && cd order-service  
go mod init github.com/ecommerce/order-service
echo 'package main\n\nfunc main() { println("Order Service") }' > main.go
dvm create app order-service --from-cwd --description "Order processing service"
dvm create workspace dev

# 3. View your microservices
dvm get apps
# NAME            DOMAIN            CREATED
# user-service    backend-services  2024-02-19 10:00
# product-service backend-services  2024-02-19 10:01  
# order-service   backend-services  2024-02-19 10:02

# 4. Work on any service
dvm use app user-service
dvm build && dvm attach

Full-Stack Project (Multiple Domains)

Set up frontend and backend together:

# 1. Create ecosystem
dvm create ecosystem myapp

# 2. Create backend domain and app
dvm create domain backend
mkdir ~/Developer/myapp-backend && cd ~/Developer/myapp-backend
go mod init github.com/myorg/myapp-backend  
echo 'package main\n\nfunc main() { println("Backend API") }' > main.go
dvm create app myapp-backend --from-cwd --description "REST API backend"
dvm create workspace dev

# 3. Create frontend domain and app  
dvm create domain frontend
mkdir ~/Developer/myapp-frontend && cd ~/Developer/myapp-frontend
npm init -y && npm install react typescript @types/react
dvm create app myapp-frontend --from-cwd --description "React frontend"
dvm create workspace dev

# 4. Switch between frontend and backend
dvm use domain backend && dvm use app myapp-backend
dvm build && dvm attach  # Go development environment

# In another terminal:
dvm use domain frontend && dvm use app myapp-frontend  
dvm build && dvm attach  # Node.js/React development environment

---

Project Organization Best Practices

Naming Conventions

Professional/EnterprisePersonal ProjectsOpen Source

# Use company/team structure
dvm create ecosystem acme-corp
dvm create domain customer-platform
dvm create app user-auth-service
dvm create workspace dev

dvm create domain data-platform  
dvm create app analytics-pipeline
dvm create workspace prod-debug

# Use simpler personal structure
dvm create ecosystem personal
dvm create domain webapps
dvm create app my-blog
dvm create workspace dev

dvm create domain tools
dvm create app backup-script  
dvm create workspace testing

# Mirror GitHub organization
dvm create ecosystem kubernetes  # GitHub org
dvm create domain core-components
dvm create app kubectl
dvm create workspace feature-new-command

Workspace Strategies

Create workspaces that match your development workflow:

# By purpose
dvm create workspace dev --description "Main development"
dvm create workspace test --description "Running test suites"  
dvm create workspace debug --description "Debugging issues"
dvm create workspace demo --description "Demo preparation"

# By feature branch
dvm create workspace feature-auth --description "Authentication feature"
dvm create workspace feature-payments --description "Payment integration"
dvm create workspace hotfix-security --description "Security patch"

# By environment
dvm create workspace local-dev --description "Local development"
dvm create workspace integration --description "Integration testing"
dvm create workspace perf-testing --description "Performance testing"

Adding Descriptions

Always add descriptions to make your project discoverable:

# Good descriptions
dvm create app user-management-api --from-cwd \
  --description "REST API for user authentication and profile management"

dvm create app data-processor --from-cwd \
  --description "ETL pipeline for processing customer analytics data"

# View descriptions
dvm get apps -o yaml  # Shows descriptions in YAML output

---

Development Workflow Examples

Typical Day with New Project

# Morning: Start new feature
dvm use app my-project
dvm create workspace feature-notifications --description "Push notification system"
dvm use workspace feature-notifications
dvm build
dvm attach

# Inside container: Work on code
git checkout -b feature/push-notifications
nvim src/notifications.py  # Full LSP support
python -m pytest tests/    # Run tests

# Exit container when done
exit

# Evening: Switch back to main development
dvm use workspace dev
dvm attach

Code Review Workflow

# Reviewer: Pull down PR branch in separate workspace
cd ~/Developer/team-project
git fetch origin pull/123/head:pr-123
git checkout pr-123

dvm create workspace review-pr-123 --description "Code review for PR #123"
dvm use workspace review-pr-123
dvm build && dvm attach

# Review code in isolation with fresh environment
nvim src/new-feature.py
python -m pytest tests/test_new_feature.py

# Clean up when done
exit
dvm delete workspace review-pr-123

---

Troubleshooting New Projects

Language Not Detected

# Check what dvm detected
dvm build --verbose

# Force language detection by creating proper files
# For Python: requirements.txt or pyproject.toml
# For Node.js: package.json  
# For Go: go.mod
# For Rust: Cargo.toml

Missing Dependencies

# Add dependencies before building
# Go example:
go mod tidy

# Python example:  
echo "fastapi>=0.100.0" >> requirements.txt

# Node.js example:
npm install express

# Then rebuild
dvm rebuild

Port Conflicts

# Check what's running
dvm get workspaces  # Shows container status

# Kill conflicting containers
dvm detach          # Exit current
docker ps           # Check Docker containers
docker stop <id>    # Stop conflicting container

---

Next Steps

After creating your project:

1. Build & Attach Guide - Learn container lifecycle management
2. Workspace Configuration - Customize your development environment
3. Theme System - Set up visual themes that match your preferences
4. Plugin Management - Add Neovim plugins for your language
5. CI/CD Integration - Use DevOpsMaestro in your deployment pipeline

---

Cheat Sheet for New Projects

# Quick Go API
mkdir go-api && cd go-api && go mod init app
dvm create eco personal && dvm create dom apis && dvm create a go-api --from-cwd && dvm create ws dev
dvm build && dvm attach

# Quick Python Web App  
mkdir python-web && cd python-web && echo "fastapi>=0.100.0" > requirements.txt
dvm create eco personal && dvm create dom web && dvm create a python-web --from-cwd && dvm create ws dev
dvm build && dvm attach

# Quick Node.js App
mkdir node-app && cd node-app && npm init -y && npm install express
dvm create eco personal && dvm create dom web && dvm create a node-app --from-cwd && dvm create ws dev  
dvm build && dvm attach

# Quick Rust Tool
cargo new rust-tool && cd rust-tool
dvm create eco personal && dvm create dom tools && dvm create a rust-tool --from-cwd && dvm create ws dev
dvm build && dvm attach