VALORA

The future of software development is not about replacing developers, but amplifying their capabilities with intelligent AI collaboration.

Features • Quick Start • Architecture • Commands • Documentation

🏛️ About VALORA

VALORA (Versatile Agent Logic for Orchestrated Response Architecture) is a next-generation TypeScript-based platform designed to orchestrate a sophisticated network of AI agents to automate the complete software development lifecycle. By moving beyond simple "code generation", VALORA manages the delicate interplay between requirements, architecture, and deployment. VALORA provides intelligent automation while maintaining human oversight.

Why VALORA?

Intelligent Orchestration: VALORA coordinates 11 specialised AI agents, from @lead technical oversight to @secops-engineer compliance, ensuring the right expert is assigned to every task.

Three-Tier Flexibility: The engine adapts to your resources, offering MCP Sampling, Guided Completion, or API Fallback modes.

Phased Governance: Every project follows a rigorous 8-phase lifecycle, moving from initialisation and planning through implementation to validation and PR creation.

Strategic Optimisation: To balance depth and speed, VALORA assigns specific LLMs (like GPT-5 for planning or Claude Haiku for validation) based on the task's complexity.

VALORA is not a replacement for the developer; it is the high-fidelity instrument through which the developer conducts a full symphony of AI agents.

✨ Features

┌─ Git Worktrees (3) ──────────┐
│ ● main  abc1234              │
│ ├── exploration/exp-abc-jwt  │
│ │   def5678  ▶ RUNNING       │
│ └── feature/new-api          │
│     ghi9012                  │
└──────────────────────────────┘

🚀 Quick Start

Prerequisites

• Node.js 18+

Installation

# Install globally
pnpm add -g @windagency/valora          # pnpm
yarn global add @windagency/valora      # yarn
npm install -g @windagency/valora       # npm

# Verify installation
valora --version
# Should output: 2.3.1

Project Setup

Initialise VALORA in your project:

cd your-project
valora init         # Minimal setup (.valora/config.json)
valora init --full  # Full setup with override directories

Your First Command

# Create an implementation plan
valora plan "Add user authentication with OAuth"

The engine will:

1. Select the appropriate agent (@lead)
2. Gather codebase context
3. Generate a detailed implementation plan
4. Provide step-by-step guidance

Zero-Config Usage with Cursor subscription

No API keys? No problem. The engine works immediately using Guided Completion Mode:

valora plan "Add dark mode toggle"
# → Generates structured prompt for Cursor AI
# → Uses your Cursor subscription (free)

Optional: API Configuration

For fully autonomous execution with cloud providers:

valora config setup --quick

# Or set environment variables
export ANTHROPIC_API_KEY=sk-ant-...
export OPENAI_API_KEY=sk-...

Optional: Local Models (No API Key)

Run fully offline with Ollama or any OpenAI-compatible server:

# Install and start Ollama
ollama pull llama3.1
ollama serve

# Use it directly
valora plan "Add auth" --provider local --model llama3.1

# Or configure as default
export LOCAL_BASE_URL=http://localhost:11434/v1
export LOCAL_DEFAULT_MODEL=llama3.1

🏗️ Architecture

┌─────────────────────────────────────────────────────────────────────────┐
│                                 VALORA                                  │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│   ┌─────────────┐  ┌──────────────┐  ┌─────────────┐  ┌─────────────┐   │
│   │ CLI Layer   │  │ Orchestrator │  │ Agent Layer │  │ LLM Layer   │   │
│   │             │──│              │──│             │──│             │   │
│   │ • Commands  │  │ • Pipeline   │  │ • Registry  │  │ • Anthropic │   │
│   │ • Wizard    │  │ • Executor   │  │ • Selection │  │ • OpenAI    │   │
│   │ • Output    │  │ • Context    │  │ • Loading   │  │ • Google    │   │
│   │             │  │              │  │             │  │ • Local     │   │
│   └─────────────┘  └──────────────┘  └─────────────┘  └─────────────┘   │
│                                                                         │
│   ┌─────────────┐  ┌──────────────┐  ┌─────────────┐  ┌─────────────┐   │
│   │ Session     │  │ Config       │  │ MCP         │  │ Services    │   │
│   │             │  │              │  │             │  │             │   │
│   │ • State     │  │ • Loader     │  │ • Server    │  │ • Logging   │   │
│   │ • Context   │  │ • Schema     │  │ • Tools     │  │ • Cleanup   │   │
│   │ • History   │  │ • Providers  │  │ • Prompts   │  │ • Utils     │   │
│   └─────────────┘  └──────────────┘  └─────────────┘  └─────────────┘   │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

Key Design Principles

📋 Commands

Complete Command Reference

Command Categories

┌─────────────────────┐  ┌─────────────────────┐  ┌─────────────────────┐
│ Planning            │  │ Implementation      │  │ Delivery            │
├─────────────────────┤  ├─────────────────────┤  ├─────────────────────┤
│ • refine-specs      │  │ • implement         │  │ • commit            │
│ • create-prd        │  │ • assert            │  │ • create-pr         │
│ • plan              │  │ • test              │  │ • feedback          │
│ • review-plan       │  │ • review-code       │  │                     │
│ • gather-knowledge  │  │ • review-functional │  │                     │
└─────────────────────┘  └─────────────────────┘  └─────────────────────┘

📚 Documentation

👤 User Guide Getting started, workflows, and daily usage

💻 Developer Guide Architecture, codebase, and contributions

🏛️ Architecture System design and decisions

Documentation Structure

documentation/
├── README.md                    # Documentation entry point
├── user-guide/                  # For users
│   ├── quick-start.md           # 5-minute getting started
│   ├── workflows.md             # Common patterns
│   └── commands.md              # Command reference
├── developer-guide/             # For developers
│   ├── setup.md                 # Development environment
│   ├── codebase.md              # Code structure
│   └── contributing.md          # How to contribute
├── architecture/                # For architects
│   ├── system-architecture.md   # C4 diagrams
│   ├── components.md            # Component design
│   └── data-flow.md             # Data flow patterns
└── adr/                         # Decision records
    ├── 001-multi-agent-architecture.md
    ├── ...
    ├── 008-pretooluse-cli-enforcement.md
    └── 009-supply-chain-hardening.md

🎯 Use Cases

New Feature Development

valora refine-specs "User authentication with OAuth"
valora create-prd
valora create-backlog
valora fetch-task && valora plan
valora implement
valora review-code && valora commit
valora create-pr

Bug Fix Workflow

valora plan "Fix: Login timeout issue"
valora implement
valora test --type=all
valora commit --scope=fix

Code Review

valora review-code --focus=security
valora review-functional --check-a11y=true

🔧 Project Structure

valora/                          # npm package root
├── bin/                         # CLI entry points
│   ├── valora.js                # Main CLI
│   └── mcp.js                   # MCP server
├── src/                         # TypeScript source
│   ├── ast/                     # AST-based code intelligence (tree-sitter parsing, symbol index)
│   ├── cli/                     # Command-line interface
│   ├── config/                  # Configuration management
│   ├── executor/                # Pipeline execution
│   ├── llm/                     # LLM provider integrations
│   ├── lsp/                     # LSP integration (language server protocol client)
│   ├── mcp/                     # MCP server implementation
│   ├── security/                # Agentic AI security (credential, command, injection guards)
│   ├── session/                 # Session management
│   │   └── worktree-stats-tracker.ts  # Worktree usage statistics
│   ├── ui/                      # Terminal UI (dashboard, panels)
│   ├── utils/                   # Utilities & path resolution
│   └── ...
├── data/                        # Built-in resources (shipped with package)
│   ├── agents/                  # Agent definitions (11 agents)
│   ├── commands/                # Command specifications (24 commands)
│   ├── prompts/                 # Structured prompts by phase
│   ├── templates/               # Document templates
│   ├── hooks/                   # Hook scripts
│   ├── config.default.json      # Default configuration
│   ├── hooks.default.json       # Default hooks config
│   └── external-mcp.default.json # External MCP server registry
├── dist/                        # Compiled output (gitignored)
├── tests/                       # Test suites
├── documentation/               # Comprehensive docs
└── package.json

Project-Level Overrides (.valora/)

When installed in a project, VALORA supports a .valora/ directory for local overrides:

.valora/                         # Project-specific configuration
├── config.json                  # Project settings (overrides defaults)
├── agents/                      # Custom/override agent definitions
├── commands/                    # Custom/override command specs
├── prompts/                     # Custom/override prompts
├── templates/                   # Custom/override templates
├── sessions/                    # Session state (gitignored)
├── logs/                        # Execution logs (gitignored)
├── index/                       # Codebase symbol index (gitignored)
└── cache/                       # Cache data (gitignored)

Resources in .valora/ take precedence over built-in data/ resources.

🌟 Why VALORA?

Innovation Highlights

🛠️ Technology Stack

📄 Licence

MIT © Damien TIVELET

Get Started • Contribute • Learn More