openexec-planner 0.1.5

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 planner follows a logical project lifecycle. Follow these steps to go from an idea to a fully ordered task DAG.

1. Initialize Project

First, bootstrap the OpenExec structure in your current directory. This creates the .openexec folder and a default configuration.

openexec-planner init

2. Gather Intent (Wizard)

If you only have a rough idea, use the interactive wizard to define your project shape, platforms, and technical contracts.

openexec-planner wizard

The wizard will chat with you, save its progress, and finally render an INTENT.md file.

3. Generate Implementation Plan

Transform your INTENT.md into structured user stories and technical tasks using an LLM.

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

4. Optimize the Schedule

Take the generated stories and calculate an optimized execution schedule. This performs a topological sort to handle dependencies and groups tasks into parallel phases.

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

---

Full Ecosystem Workflow

OpenExec is designed as a Brain (Planner) and a Body (Executor).

1. Plan (Python): Use openexec-planner (this package) to build the tasks.json roadmap.
2. Execute (Go): Use the OpenExec Engine to run the tasks.

# Once tasks.json is generated in step 4:
openexec start --ui
openexec run

---

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 — Unified Go Execution Engine, Server, and Web Dashboard
• openexec.io — Official Website and Documentation

License

MIT License