openexec-planner 0.1.0

AI Project Planning Engine - From Intent to Executable Task DAGs

OpenExec Planner

AI Project Planning Engine — From Intent to Executable Task DAGs

---

The OpenExec Planner module transforms high-level project intents (PRDs, specs, requirements) into structured, executable task hierarchies using AI-powered decomposition and goal tree analysis.

Features

• Guided Intent Interviewer — Interactive chat to gather constraints and shape
• Intent Parsing — Extracts goals and requirements from PRD documents
• Goal Tree Decomposition — Breaks down objectives into atomic tasks
• Story Generation — Creates user stories with acceptance criteria
• Dependency Modeling — Infers and models execution prerequisites for parallel processing
• Dependency Analysis — Identifies task relationships and ordering
• Quality Gate Templates — Language-aware testing configurations
• Context Awareness — Integrates with codebase analysis

How It Works

┌─────────────┐     ┌──────────────┐     ┌─────────────┐
│   INTENT    │────▶│    PARSER    │────▶│  GOAL TREE  │
│  (PRD.md)   │     │  (AI Agent)  │     │   (JSON)    │
└─────────────┘     └──────────────┘     └──────┬──────┘
                                                │
                    ┌───────────────────────────┘
                    ▼
┌─────────────┐     ┌──────────────┐     ┌─────────────┐
│   STORIES   │────▶│    TASKS     │────▶│   SCHEDULE  │
│  (JSON)     │     │   (JSON)     │     │  (ordered)  │
└─────────────┘     └──────────────┘     └─────────────┘

Installation

git clone https://github.com/openexec/openexec-planner.git
cd openexec-planner
pip install -e .

CLI Dependencies

By default, the orchestration engine uses external CLI tools to call LLMs. Ensure you have the relevant tools installed and authenticated:

• Claude Code: claude CLI
• Codex: codex CLI
• Gemini: gemini CLI
• OpenCode: opencode (Ollama)

To use direct API calls instead, install the optional dependencies:

pip install "openexec-planner[llm]"

Usage

The orchestration engine follows a logical project lifecycle:

1. Gather Intent (Wizard)

Start a guided interview to define your project shape, platform, and contracts. This is the recommended first step for any new project or refactor.

openexec-planner wizard --message "I want to build a new mobile app for gym tracking"

The wizard will track state and ask follow-up questions until the intent is "Ready", then render an INTENT.md file.

2. Generate Plan (Generate)

Once you have an INTENT.md (either from the wizard or manual), transform it into structured user stories and tasks.

openexec-planner generate INTENT.md -o .openexec/stories.json

3. Analyze Architecture (Build Tree)

Decompose the goals into a hierarchical tree to visualize the project structure.

openexec-planner build-tree INTENT.md -o .openexec/goal_tree.json

4. Order Execution (Schedule)

Generate an optimized execution schedule based on task dependencies.

openexec-planner schedule .openexec/stories.json -o .openexec/schedule.json

Configuration

# openexec.yaml
orchestration:
  agent: claude                  # AI agent for planning
  model: sonnet                  # Model for decomposition
  max_depth: 4                   # Goal tree max depth
  min_task_granularity: 2h       # Minimum task size
  max_task_granularity: 8h       # Maximum task size

planning:
  include_tests: true            # Generate test tasks
  include_docs: false            # Generate doc tasks
  language_detection: auto       # Detect project language

Output Formats

stories.json

{
  "stories": [
    {
      "id": "US-001",
      "title": "User Registration",
      "description": "As a user, I want to register...",
      "acceptance_criteria": [
        "User can enter email and password",
        "Email validation is performed",
        "Success message is shown"
      ],
      "tasks": ["T-001", "T-002", "T-003"]
    }
  ]
}

tasks.json

{
  "tasks": [
    {
      "id": "T-001",
      "story_id": "US-001",
      "title": "Create registration form component",
      "description": "...",
      "status": "pending",
      "dependencies": [],
      "estimated_hours": 4
    }
  ]
}

goal-tree.json

{
  "root": {
    "goal": "Build user authentication",
    "children": [
      {
        "goal": "User registration",
        "children": [
          {"task": "T-001"},
          {"task": "T-002"}
        ]
      }
    ]
  }
}

Project Structure

openexec-planner/
├── src/
│   └── openexec_planner/
│       ├── __init__.py
│       ├── parser.py           # Intent parsing
│       ├── generator.py        # Story generation
│       ├── goal_tree.py        # Goal tree building
│       ├── scheduler.py        # Task scheduling
│       └── templates/          # Prompt templates
├── tests/
├── pyproject.toml
└── README.md

Language Detection

Automatically detects project language and configures appropriate:

• Quality gates (lint, test, typecheck)
• File patterns
• Build commands

Supported languages:

• Python (ruff, mypy, pytest)
• Go (gofmt, golangci-lint, go test)
• TypeScript/JavaScript (eslint, tsc, jest)
• Rust (cargo fmt, clippy, cargo test)

Development

# Install dev dependencies
pip install -e ".[dev]"

# Run tests
pytest

# Lint
ruff check src/

# Type check
mypy src/

Related

• openexec — Main documentation
• initial — Python CLI (feature-complete)
• openexec-execution — Execution engine
• openexec-cli — Go CLI with TUI

License

MIT License