execforge 0.1.0__py3-none-any.whl

orchestrator/prompts/parser.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from hashlib import sha256
+from pathlib import Path
+import re
+
+import yaml
+
+from orchestrator.domain.types import PromptTask, TaskGitPolicy, TaskStep
+
+
+FRONTMATTER_RE = re.compile(r"^---\s*\n(.*?)\n---\s*\n(.*)$", re.DOTALL)
+
+
+def _parse_steps(metadata: dict, body: str) -> list[TaskStep]:
+    steps: list[TaskStep] = []
+    for idx, item in enumerate(list(metadata.get("steps", []) or []), start=1):
+        if not isinstance(item, dict):
+            continue
+        step_id = str(item.get("id") or f"step-{idx}")
+        step_type = str(item.get("type") or "llm_summary")
+        steps.append(
+            TaskStep(
+                id=step_id,
+                type=step_type,
+                tool_preferences=list(item.get("tool_preferences", []) or []),
+                prompt_file=item.get("prompt_file"),
+                prompt_inline=item.get("prompt_inline"),
+                command=item.get("command"),
+                metadata={k: v for k, v in item.items() if k not in {"id", "type", "tool_preferences", "prompt_file", "prompt_inline", "command"}},
+            )
+        )
+
+    if steps:
+        return steps
+
+    # Backward-compatible fallback: a single summary step from body.
+    if body.strip():
+        return [TaskStep(id="default", type="llm_summary", prompt_inline=body.strip())]
+    return []
+
+
+def _parse_git_policy(metadata: dict) -> TaskGitPolicy:
+    data = metadata.get("git") or {}
+    if not isinstance(data, dict):
+        return TaskGitPolicy()
+    return TaskGitPolicy(
+        base_branch=data.get("base_branch"),
+        work_branch=data.get("work_branch"),
+        push_on_success=data.get("push_on_success"),
+    )
+
+
+def parse_task_raw(raw: str, rel_path: str, suffix: str) -> PromptTask:
+    metadata: dict = {}
+    body = raw
+    if suffix.lower() == ".md":
+        match = FRONTMATTER_RE.match(raw)
+        if match:
+            metadata = yaml.safe_load(match.group(1)) or {}
+            body = match.group(2).strip()
+    else:
+        metadata = yaml.safe_load(raw) or {}
+        body = str(metadata.get("instructions") or metadata.get("description") or "").strip()
+
+    title = metadata.get("title") or Path(rel_path).stem
+    steps = _parse_steps(metadata, body)
+    git = _parse_git_policy(metadata)
+    task = PromptTask(
+        external_id=metadata.get("id"),
+        source_path=rel_path,
+        title=title,
+        description=body,
+        priority=metadata.get("priority", "medium"),
+        status=metadata.get("status", "todo"),
+        labels=list(metadata.get("labels", []) or []),
+        target_repo=metadata.get("target_repo"),
+        target_paths=list(metadata.get("target_paths", []) or []),
+        depends_on=list(metadata.get("depends_on", []) or []),
+        acceptance_criteria=list(metadata.get("acceptance_criteria", []) or []),
+        steps=steps,
+        git=git,
+        raw_content=raw,
+        last_seen_hash=sha256(raw.encode("utf-8")).hexdigest(),
+    )
+    return task
+
+
+def parse_task_file(path: Path, rel_path: str) -> PromptTask:
+    raw = path.read_text(encoding="utf-8")
+    return parse_task_raw(raw, rel_path=rel_path, suffix=path.suffix)

orchestrator/reporting/__init__.py

@@ -0,0 +1 @@
+"""Console and event reporting for runtime execution."""

orchestrator/reporting/console.py

@@ -0,0 +1,197 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+
+from orchestrator.reporting.events import LogEvent, clean_context
+
+
+def _fmt_time(value: str | datetime | None) -> str:
+    if isinstance(value, datetime):
+        return value.strftime("%Y-%m-%d %H:%M:%S")
+    if isinstance(value, str) and value:
+        return value
+    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+
+@dataclass(slots=True)
+class ConsoleReporter:
+    mode: str = "default"  # default | verbose | debug
+    warnings_in_run: int = 0
+
+    def _print(self, text: str = "") -> None:
+        print(text)
+
+    def render(self, event: LogEvent) -> None:
+        if self.mode == "debug":
+            self._print(str(event.to_dict()))
+            return
+
+        name = event.name
+        context = clean_context(event.context)
+
+        if name == "loop_started":
+            self._print("=" * 60)
+            self._print("Execforge Loop Started")
+            self._print(f"  Time: {_fmt_time(context.get('time'))}")
+            self._print(f"  Agent: {context.get('agent')}")
+            self._print(f"  Project: {context.get('project')}")
+            self._print(f"  Prompt Source: {context.get('prompt_source')}")
+            self._print(f"  Interval: {context.get('interval_seconds')}s")
+            self._print(f"  Only New Prompts: {str(context.get('only_new_prompts', True)).lower()}")
+            self._print(f"  Reset Only New Baseline: {str(context.get('reset_only_new_baseline', False)).lower()}")
+            self._print(f"  Initial Excluded Tasks: {context.get('initial_excluded', 0)}")
+            self._print(f"  Allow Dirty Working Tree: {str(context.get('allow_dirty_worktree', False)).lower()}")
+            if context.get("branch_strategy"):
+                self._print(f"  Branch Strategy: {context.get('branch_strategy')}")
+            self._print("=" * 60)
+            self._print("")
+            return
+
+        if name == "run_started":
+            self.warnings_in_run = 0
+            self._print("-" * 60)
+            self._print("Execforge Run")
+            self._print(f"  Run: {context.get('run_id')}")
+            self._print(f"  Time: {_fmt_time(context.get('time'))}")
+            self._print(f"  Agent: {context.get('agent')}")
+            self._print(f"  Project: {context.get('project')}")
+            self._print(f"  Prompt Source: {context.get('prompt_source')}")
+            self._print("-" * 60)
+            self._print("")
+            return
+
+        if name in {"prompt_sync_started", "repo_validate_started", "task_select_started", "branch_prepare_started", "steps_started"}:
+            idx = event.phase_index or 0
+            total = event.phase_total or 0
+            self._print(f"[{idx}/{total}] {event.title}...")
+            return
+
+        if name == "prompt_synced":
+            self._print(f"  Found {context.get('discovered_tasks', 0)} task")
+            return
+
+        if name == "repo_validated":
+            branch = context.get("current_branch")
+            if branch:
+                self._print(f"  Current branch: {branch}")
+            return
+
+        if name == "task_selection_completed":
+            if context.get("selected_task_id"):
+                self._print(f"  Selected: {context.get('selected_task_id')}")
+            else:
+                self._print("  No task selected")
+                self._print(f"  Reason: {context.get('reason')}")
+                self._print(f"  Eligible tasks: {context.get('eligible_count', 0)}")
+                self._print(f"  Excluded tasks: {context.get('excluded_count', 0)}")
+                if context.get("next_hint"):
+                    self._print(f"  Next: {context.get('next_hint')}")
+                if self.mode == "verbose":
+                    if context.get("code"):
+                        self._print(f"  Outcome: {context.get('code')}")
+                    self._print(f"  Discovered tasks: {context.get('discovered_count', 0)}")
+            return
+
+        if name == "branch_prepared":
+            if context.get("base_branch"):
+                self._print(f"  Base: {context.get('base_branch')}")
+            if context.get("branch"):
+                self._print(f"  Branch: {context.get('branch')}")
+            return
+
+        if name == "step_completed":
+            i = context.get("step_index")
+            total = context.get("step_total")
+            step = context.get("step")
+            backend = context.get("backend")
+            symbol = context.get("symbol", "✓")
+            self._print(f"  [{i}/{total}] {symbol} {step:<16} {backend}")
+            return
+
+        if name == "step_failed":
+            i = context.get("step_index", "?")
+            total = context.get("step_total", "?")
+            step = context.get("step", "unknown")
+            backend = context.get("backend", "runtime")
+            self._print(f"  [{i}/{total}] ✗ {step:<16} {backend}")
+            self._print("")
+            if context.get("base_branch"):
+                self._print(f"      Base: {context.get('base_branch')}")
+            if context.get("branch"):
+                self._print(f"      Branch: {context.get('branch')}")
+            if context.get("task_id"):
+                self._print(f"      Task: {context.get('task_id')}")
+            if context.get("error"):
+                self._print(f"      Error: {context.get('error')}")
+            return
+
+        if name == "warning":
+            self.warnings_in_run += 1
+            self._print(f"⚠ {event.message}")
+            if context.get("branch"):
+                self._print(f"  Branch: {context.get('branch')}")
+            if context.get("task_id"):
+                self._print(f"  Task: {context.get('task_id')}")
+            return
+
+        if name == "run_noop":
+            self._print("")
+            self._print("Run complete")
+            self._print("  Status: noop")
+            self._print(f"  Reason: {context.get('reason', 'no actionable task found')}")
+            if context.get("next_hint"):
+                self._print(f"  Next: {context.get('next_hint')}")
+            if context.get("project"):
+                self._print(f"  Project: {context.get('project')}")
+            if context.get("warnings") is not None:
+                self._print(f"  Warnings: {context.get('warnings')}")
+            return
+
+        if name == "run_completed":
+            self._print("")
+            self._print("Run complete")
+            self._print(f"  Status: {context.get('status', 'success')}")
+            if context.get("reason"):
+                self._print(f"  Reason: {context.get('reason')}")
+            if context.get("task_id"):
+                self._print(f"  Task: {context.get('task_id')}")
+            if context.get("branch"):
+                self._print(f"  Branch: {context.get('branch')}")
+            if context.get("push_enabled") is not None:
+                self._print(f"  Push Enabled: {str(context.get('push_enabled')).lower()}")
+            if context.get("steps_total") is not None and context.get("steps_passed") is not None:
+                self._print(f"  Steps: {context.get('steps_passed')}/{context.get('steps_total')} passed")
+            warnings = context.get("warnings", self.warnings_in_run)
+            self._print(f"  Warnings: {warnings}")
+            if context.get("log_path"):
+                self._print(f"  Log File: {context.get('log_path')}")
+            return
+
+        if name == "run_failed":
+            if self.mode == "verbose":
+                self._print(f"  Failure reason: {context.get('reason')}")
+            return
+
+        if name == "loop_waiting":
+            interval = int(context.get("interval_seconds", 0) or 0)
+            next_at = context.get("next_run_at")
+            if not next_at:
+                next_at = _fmt_time(datetime.now() + timedelta(seconds=interval))
+            self._print("")
+            self._print("Waiting for next poll...")
+            self._print(f"  Next run in: {interval}s")
+            self._print(f"  Next run at: {next_at}")
+            self._print("")
+            return
+
+        if self.mode == "verbose" and event.message:
+            self._print(f"  {event.message}")
+
+
+class NullReporter(ConsoleReporter):
+    def __init__(self):
+        super().__init__(mode="default")
+
+    def render(self, event: LogEvent) -> None:
+        return

orchestrator/reporting/events.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+def clean_context(data: dict[str, Any] | None) -> dict[str, Any]:
+    if not data:
+        return {}
+    cleaned: dict[str, Any] = {}
+    for key, value in data.items():
+        if value is None:
+            continue
+        if isinstance(value, str) and value.strip() == "":
+            continue
+        cleaned[key] = value
+    return cleaned
+
+
+@dataclass(slots=True)
+class LogEvent:
+    name: str
+    level: str = "info"
+    phase_index: int | None = None
+    phase_total: int | None = None
+    title: str | None = None
+    message: str | None = None
+    context: dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        payload: dict[str, Any] = {
+            "name": self.name,
+            "level": self.level,
+        }
+        if self.phase_index is not None:
+            payload["phase_index"] = self.phase_index
+        if self.phase_total is not None:
+            payload["phase_total"] = self.phase_total
+        if self.title:
+            payload["title"] = self.title
+        if self.message:
+            payload["message"] = self.message
+        payload["context"] = clean_context(self.context)
+        return payload

orchestrator/reporting/selection_result.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(slots=True)
+class SelectionOutcome:
+    code: str
+    reason: str
+    next_hint: str | None = None
+    selected_task_id: str | None = None
+    eligible_count: int = 0
+    excluded_count: int = 0
+    discovered_count: int = 0
+    total_tasks_for_source: int = 0

orchestrator/services/__init__.py

@@ -0,0 +1 @@
+"""Application service layer."""