Rule-Based AI Task Planner Project

"""A symbolic AI task planner using explicit prerequisites."""

from __future__ import annotations

from dataclasses import dataclass


@dataclass(frozen=True)
class Task:
    name: str
    depends_on: tuple[str, ...] = ()


def tasks_for_goal(goal: str) -> dict[str, Task]:
    lower = goal.lower()
    tasks = {
        "clarify": Task("clarify"),
        "research": Task("research", ("clarify",)),
        "draft": Task("draft", ("research",)),
        "review": Task("review", ("draft",)),
        "deliver": Task("deliver", ("review",)),
    }
    if "publish" in lower or "website" in lower:
        tasks["test_links"] = Task("test_links", ("review",))
        tasks["deliver"] = Task("deliver", ("review", "test_links"))
    if "data" in lower or "report" in lower:
        tasks["validate_data"] = Task("validate_data", ("research",))
        tasks["draft"] = Task("draft", ("research", "validate_data"))
    return tasks


def topological_plan(tasks: dict[str, Task]) -> list[str]:
    ordered, visiting, visited = [], set(), set()
    def visit(name: str) -> None:
        if name in visiting:
            raise ValueError("Dependency cycle detected")
        if name in visited:
            return
        if name not in tasks:
            raise ValueError(f"Unknown dependency: {name}")
        visiting.add(name)
        for dependency in tasks[name].depends_on:
            visit(dependency)
        visiting.remove(name)
        visited.add(name)
        ordered.append(name)
    for task_name in tasks:
        visit(task_name)
    return ordered


def main() -> None:
    print(topological_plan(tasks_for_goal("Analyse data, write a report, and publish it on a website")))
    print("This symbolic planner follows visible rules; it does not understand hidden constraints.")


if __name__ == "__main__":
    main()