algo-cli-runtime 0.14.0__py3-none-any.whl

algo_cli/intelligence/acrobat_workflows.py

@@ -0,0 +1,226 @@
+"""B157-B158: Acrobat-derived workflow and policy profile patterns.
+
+- B157: Declarative Workflow Sequence Engine
+- B158: Named Policy Profile Packs
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Callable
+
+
+# ── B157: Declarative Workflow Sequence Engine ────────────────────────
+
+
+@dataclass
+class WorkflowItem:
+    """A typed parameter for a workflow command."""
+    name: str
+    item_type: str  # "boolean", "integer", "text"
+    value: Any = None
+
+
+@dataclass
+class WorkflowInstruction:
+    """An instruction step in a workflow."""
+    label: str
+
+
+@dataclass
+class WorkflowCommand:
+    """A command step in a workflow."""
+    name: str
+    prompt_user: bool = False
+    pause_before: bool = False
+    items: list[WorkflowItem] = field(default_factory=list)
+
+
+@dataclass
+class WorkflowGroup:
+    """A group of steps in a workflow."""
+    label: str
+    steps: list[WorkflowInstruction | WorkflowCommand | "WorkflowSeparator"] = field(default_factory=list)
+
+
+@dataclass
+class WorkflowSeparator:
+    """A visual separator in a workflow."""
+    pass
+
+
+@dataclass
+class WorkflowDefinition:
+    """A declarative workflow definition (B157)."""
+    title: str
+    description: str = ""
+    major_version: int = 1
+    minor_version: int = 0
+    groups: list[WorkflowGroup] = field(default_factory=list)
+
+    def all_command_names(self) -> list[str]:
+        """Extract all command names from the workflow."""
+        names: list[str] = []
+        for group in self.groups:
+            for step in group.steps:
+                if isinstance(step, WorkflowCommand):
+                    names.append(step.name)
+        return names
+
+    def validate(self, command_registry: set[str]) -> list[str]:
+        """Validate workflow against a command registry. Returns errors."""
+        errors: list[str] = []
+        for name in self.all_command_names():
+            if name not in command_registry:
+                errors.append(f"unknown command: {name}")
+        # Validate typed items
+        for group in self.groups:
+            for step in group.steps:
+                if isinstance(step, WorkflowCommand):
+                    for item in step.items:
+                        if item.item_type == "boolean" and not isinstance(item.value, bool | type(None)):
+                            if item.value is not None:
+                                errors.append(f"bad boolean value for {item.name}: {item.value}")
+                        elif item.item_type == "integer" and item.value is not None:
+                            if not isinstance(item.value, int):
+                                errors.append(f"bad integer value for {item.name}: {item.value}")
+        return errors
+
+
+@dataclass
+class WorkflowStepResult:
+    """Result of executing a single workflow step."""
+    step_name: str
+    success: bool = True
+    output: Any = None
+    skipped: bool = False
+    error: str = ""
+
+
+@dataclass
+class WorkflowExecutionResult:
+    """Result of executing an entire workflow."""
+    title: str
+    steps: list[WorkflowStepResult] = field(default_factory=list)
+    completed: bool = False
+    paused_at: str = ""
+
+    @property
+    def failed_steps(self) -> list[WorkflowStepResult]:
+        return [s for s in self.steps if not s.success and not s.skipped]
+
+
+class WorkflowExecutor:
+    """Executes declarative workflows (B157)."""
+
+    def __init__(self) -> None:
+        self._handlers: dict[str, Callable[[dict], Any]] = {}
+
+    def register_command(self, name: str, handler: Callable[[dict], Any]) -> None:
+        self._handlers[name] = handler
+
+    def validate(self, workflow: WorkflowDefinition) -> list[str]:
+        """Validate a workflow before execution."""
+        return workflow.validate(set(self._handlers.keys()))
+
+    def execute(self, workflow: WorkflowDefinition, context: dict | None = None) -> WorkflowExecutionResult:
+        """Execute a workflow step by step."""
+        ctx = context or {}
+        result = WorkflowExecutionResult(title=workflow.title)
+        errors = self.validate(workflow)
+        if errors:
+            result.steps.append(WorkflowStepResult(
+                step_name="validation",
+                success=False,
+                error="; ".join(errors),
+            ))
+            return result
+
+        for group in workflow.groups:
+            for step in group.steps:
+                if isinstance(step, WorkflowInstruction | WorkflowSeparator):
+                    continue
+                if isinstance(step, WorkflowCommand):
+                    if step.pause_before:
+                        result.paused_at = step.name
+                        return result
+                    handler = self._handlers.get(step.name)
+                    if not handler:
+                        result.steps.append(WorkflowStepResult(
+                            step_name=step.name,
+                            success=False,
+                            error=f"no handler: {step.name}",
+                        ))
+                        return result
+                    try:
+                        item_dict = {item.name: item.value for item in step.items}
+                        output = handler({**ctx, **item_dict})
+                        result.steps.append(WorkflowStepResult(
+                            step_name=step.name,
+                            success=True,
+                            output=output,
+                        ))
+                    except Exception as e:
+                        result.steps.append(WorkflowStepResult(
+                            step_name=step.name,
+                            success=False,
+                            error=str(e),
+                        ))
+                        return result
+        result.completed = True
+        return result
+
+
+# ── B158: Named Policy Profile Packs ──────────────────────────────────
+
+
+@dataclass
+class PolicyProfile:
+    """A named policy profile (B158)."""
+    name: str
+    description: str = ""
+    parameters: dict[str, Any] = field(default_factory=dict)
+    overrides: dict[str, Any] = field(default_factory=dict)
+    source: str = "shipped"  # "shipped" or "user"
+
+    def resolve(self, defaults: dict[str, Any]) -> dict[str, Any]:
+        """Resolve profile against defaults, applying overrides."""
+        result = dict(defaults)
+        result.update(self.parameters)
+        result.update(self.overrides)
+        return result
+
+
+class PolicyProfilePack:
+    """A collection of named policy profiles (B158)."""
+
+    def __init__(self) -> None:
+        self._profiles: dict[str, PolicyProfile] = {}
+        self._defaults: dict[str, Any] = {}
+
+    def set_defaults(self, defaults: dict[str, Any]) -> None:
+        self._defaults = dict(defaults)
+
+    def register(self, profile: PolicyProfile) -> None:
+        self._profiles[profile.name] = profile
+
+    def get(self, name: str) -> PolicyProfile | None:
+        return self._profiles.get(name)
+
+    def resolve(self, name: str) -> dict[str, Any] | None:
+        """Resolve a profile by name."""
+        profile = self._profiles.get(name)
+        if not profile:
+            return None
+        return profile.resolve(self._defaults)
+
+    def available_profiles(self) -> list[str]:
+        return list(self._profiles.keys())
+
+    def add_user_override(self, profile_name: str, key: str, value: Any) -> bool:
+        """Add a user override to a profile."""
+        profile = self._profiles.get(profile_name)
+        if not profile:
+            return False
+        profile.overrides[key] = value
+        return True

algo_cli/intelligence/actionability.py

@@ -0,0 +1,165 @@
+"""B43. Auto-Wait Actionability Checks (Playwright Pattern).
+
+Before performing an action (click, type, navigate), check that the target
+is ready: exists, visible, stable, enabled, and receives input.  No blind
+sleeps — poll with timeout until conditions are met or fail fast.
+"""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+from typing import Any, Callable
+
+
+class CheckResult:
+    PASSED = "passed"
+    FAILED = "failed"
+    TIMEOUT = "timeout"
+
+
+@dataclass
+class ActionabilityCheck:
+    name: str
+    check_fn: Callable[[], bool]
+    timeout_ms: int = 5000
+    poll_interval_ms: int = 100
+
+
+@dataclass
+class ActionabilityReport:
+    checks: dict[str, str] = field(default_factory=dict)  # name -> result
+    all_passed: bool = False
+    duration_ms: float = 0.0
+    failed_checks: list[str] = field(default_factory=list)
+
+
+def auto_wait(checks: list[ActionabilityCheck]) -> ActionabilityReport:
+    """Run all actionability checks with polling and timeout.
+
+    Each check is polled at its interval until it passes or times out.
+    All checks must pass for the report to be all_passed=True.
+    """
+    start = time.monotonic()
+    results: dict[str, str] = {}
+    failed: list[str] = []
+
+    for check in checks:
+        deadline = time.monotonic() + check.timeout_ms / 1000
+        passed = False
+        while time.monotonic() < deadline:
+            try:
+                if check.check_fn():
+                    passed = True
+                    break
+            except Exception:
+                pass
+            time.sleep(check.poll_interval_ms / 1000)
+
+        if passed:
+            results[check.name] = CheckResult.PASSED
+        elif time.monotonic() >= deadline:
+            results[check.name] = CheckResult.TIMEOUT
+            failed.append(check.name)
+        else:
+            results[check.name] = CheckResult.FAILED
+            failed.append(check.name)
+
+    duration = (time.monotonic() - start) * 1000
+    return ActionabilityReport(
+        checks=results,
+        all_passed=len(failed) == 0,
+        duration_ms=duration,
+        failed_checks=failed,
+    )
+
+
+# ── standard checks ───────────────────────────────────────────────────
+
+
+def check_exists(predicate: Callable[[], Any]) -> ActionabilityCheck:
+    """Target exists (not None)."""
+    return ActionabilityCheck(
+        name="exists",
+        check_fn=lambda: predicate() is not None,
+    )
+
+
+def check_visible(predicate: Callable[[], bool]) -> ActionabilityCheck:
+    """Target is visible."""
+    return ActionabilityCheck(
+        name="visible",
+        check_fn=predicate,
+    )
+
+
+def check_stable(predicate: Callable[[], bool], samples: int = 3, interval: float = 0.05) -> ActionabilityCheck:
+    """Target has not changed over N consecutive samples."""
+    last_values: list[Any] = []
+
+    def is_stable() -> bool:
+        val = predicate()
+        last_values.append(val)
+        if len(last_values) > samples:
+            last_values.pop(0)
+        if len(last_values) < samples:
+            return False
+        return all(v == last_values[0] for v in last_values)
+
+    return ActionabilityCheck(name="stable", check_fn=is_stable)
+
+
+def check_enabled(predicate: Callable[[], bool]) -> ActionabilityCheck:
+    """Target is enabled (not disabled)."""
+    return ActionabilityCheck(
+        name="enabled",
+        check_fn=predicate,
+    )
+
+
+def check_receives_input(predicate: Callable[[], bool]) -> ActionabilityCheck:
+    """Target can receive input (focusable)."""
+    return ActionabilityCheck(
+        name="receives_input",
+        check_fn=predicate,
+    )
+
+
+# ── trace recorder ────────────────────────────────────────────────────
+
+
+@dataclass
+class ActionTrace:
+    action: str
+    target: str
+    report: ActionabilityReport
+    timestamp: float = field(default_factory=time.time)
+    screenshot_path: str = ""
+    html_snapshot: str = ""
+    console_logs: list[str] = field(default_factory=list)
+    network_summary: dict[str, Any] = field(default_factory=dict)
+
+
+class TraceRecorder:
+    """Records action traces for debugging and replay."""
+
+    def __init__(self) -> None:
+        self.traces: list[ActionTrace] = []
+
+    def record(self, action: str, target: str, report: ActionabilityReport, **kwargs: Any) -> None:
+        self.traces.append(ActionTrace(
+            action=action, target=target, report=report, **kwargs,
+        ))
+
+    def failed_actions(self) -> list[ActionTrace]:
+        return [t for t in self.traces if not t.report.all_passed]
+
+    def summary(self) -> dict[str, Any]:
+        total = len(self.traces)
+        passed = sum(1 for t in self.traces if t.report.all_passed)
+        return {
+            "total_actions": total,
+            "passed": passed,
+            "failed": total - passed,
+            "avg_wait_ms": sum(t.report.duration_ms for t in self.traces) / max(total, 1),
+        }

algo_cli/intelligence/adversarial_audit.py

@@ -0,0 +1,136 @@
+"""H8 — Adversarial Self-Audit.
+
+Catches fabricated or exaggerated claims by comparing claimed behavior
+against actual test results.
+Mined from GLOSSOPETRAE §6.5 falsify_workflow.mjs.
+
+LLM integration: optionally uses an LLM to analyze discrepancies.
+Falls back to rule-based comparison when no model is available.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class Claim:
+    """A claimed behavior to audit."""
+
+    entry_id: str
+    claimed_status: str  # "implemented", "partial", "planned"
+    claimed_tests: list[str] = field(default_factory=list)
+    description: str = ""
+
+
+@dataclass
+class AuditResult:
+    """Result of auditing a single claim."""
+
+    entry_id: str
+    passed: bool
+    discrepancies: list[str] = field(default_factory=list)
+    actual_status: str = ""
+    verified_tests: list[str] = field(default_factory=list)
+
+
+def audit_claim(
+    claim: Claim,
+    actual_tests: list[str],
+    actual_status: str,
+    model_client: Any | None = None,
+) -> AuditResult:
+    """Audit a single claim against actual results.
+
+    Args:
+        claim: The claimed behavior.
+        actual_tests: List of actual test names that passed.
+        actual_status: The actual status string.
+        model_client: Optional LLM for deeper analysis.
+
+    Returns:
+        AuditResult with discrepancies found.
+    """
+    discrepancies: list[str] = []
+
+    # Check status mismatch
+    if claim.claimed_status != actual_status:
+        discrepancies.append(
+            f"Status mismatch: claimed '{claim.claimed_status}', actual '{actual_status}'"
+        )
+
+    # Check missing tests
+    claimed_set = set(claim.claimed_tests)
+    actual_set = set(actual_tests)
+    missing = claimed_set - actual_set
+    if missing:
+        discrepancies.append(f"Missing tests: {sorted(missing)}")
+
+    # Check extra tests (not necessarily bad, but worth noting)
+    extra = actual_set - claimed_set
+    if extra and claim.claimed_tests:
+        discrepancies.append(f"Unclaimed tests: {sorted(extra)}")
+
+    # If claimed implemented but no tests, that's fabrication
+    if claim.claimed_status == "implemented" and not actual_tests:
+        discrepancies.append("Claimed 'implemented' but no passing tests found")
+
+    passed = len(discrepancies) == 0
+    return AuditResult(
+        entry_id=claim.entry_id,
+        passed=passed,
+        discrepancies=discrepancies,
+        actual_status=actual_status,
+        verified_tests=list(actual_set),
+    )
+
+
+def audit_batch(
+    claims: list[Claim],
+    actual_results: dict[str, tuple[list[str], str]],
+    model_client: Any | None = None,
+) -> list[AuditResult]:
+    """Audit multiple claims against actual results.
+
+    Args:
+        claims: List of claimed behaviors.
+        actual_results: Dict mapping entry_id to (test_names, status).
+        model_client: Optional LLM for deeper analysis.
+
+    Returns:
+        List of AuditResults.
+    """
+    results: list[AuditResult] = []
+    for claim in claims:
+        if claim.entry_id in actual_results:
+            tests, status = actual_results[claim.entry_id]
+            results.append(audit_claim(claim, tests, status, model_client))
+        else:
+            results.append(
+                AuditResult(
+                    entry_id=claim.entry_id,
+                    passed=False,
+                    discrepancies=[f"No actual results found for entry '{claim.entry_id}'"],
+                    actual_status="missing",
+                    verified_tests=[],
+                )
+            )
+    return results
+
+
+def summarize_audit(results: list[AuditResult]) -> dict[str, Any]:
+    """Summarize audit results."""
+    total = len(results)
+    passed = sum(1 for r in results if r.passed)
+    failed = total - passed
+    all_discrepancies: list[str] = []
+    for r in results:
+        all_discrepancies.extend(r.discrepancies)
+    return {
+        "total": total,
+        "passed": passed,
+        "failed": failed,
+        "pass_rate": passed / total if total > 0 else 0.0,
+        "discrepancies": all_discrepancies,
+        "discrepancy_count": len(all_discrepancies),
+    }

algo_cli/intelligence/agent_arena.py

@@ -0,0 +1,92 @@
+"""B58. Agent Arena: Multi-Model Head-to-Head.
+
+Run the same task across multiple models and compare outputs.
+Source: qwen-code pattern.
+"""
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+from enum import Enum, auto
+from typing import Callable
+
+
+class ArenaOutcome(Enum):
+    WINNER = auto()
+    TIE = auto()
+    ALL_FAILED = auto()
+
+
+@dataclass
+class ArenaEntry:
+    model: str
+    output: str = ""
+    duration_s: float = 0.0
+    token_count: int = 0
+    error: str | None = None
+    success: bool = True
+
+
+@dataclass
+class ArenaResult:
+    task: str
+    entries: list[ArenaEntry] = field(default_factory=list)
+    winner: str | None = None
+    outcome: ArenaOutcome = ArenaOutcome.TIE
+    comparison: str = ""
+
+
+class AgentArena:
+    """Run the same task across multiple models and compare."""
+
+    def __init__(self, judge_fn: Callable[[str, list[ArenaEntry]], str] | None = None) -> None:
+        self._judge = judge_fn or self._default_judge
+
+    @staticmethod
+    def _default_judge(task: str, entries: list[ArenaEntry]) -> str:
+        """Default judge: pick the longest successful output."""
+        successful = [e for e in entries if e.success and e.output]
+        if not successful:
+            return ""
+        return max(successful, key=lambda e: len(e.output)).model
+
+    def run(
+        self,
+        task: str,
+        models: dict[str, Callable[[str], str]],
+        timeout: float = 30.0,
+    ) -> ArenaResult:
+        """Run task on all models, return comparison."""
+        result = ArenaResult(task=task)
+        for model_name, run_fn in models.items():
+            entry = ArenaEntry(model=model_name)
+            start = time.time()
+            try:
+                entry.output = run_fn(task)
+                entry.token_count = len(entry.output) // 4
+            except Exception as e:
+                entry.error = str(e)
+                entry.success = False
+            entry.duration_s = time.time() - start
+            result.entries.append(entry)
+
+        # Judge
+        winner = self._judge(task, result.entries)
+        if winner:
+            result.winner = winner
+            result.outcome = ArenaOutcome.WINNER
+        elif any(e.success for e in result.entries):
+            result.outcome = ArenaOutcome.TIE
+        else:
+            result.outcome = ArenaOutcome.ALL_FAILED
+
+        result.comparison = self._format_comparison(result)
+        return result
+
+    @staticmethod
+    def _format_comparison(result: ArenaResult) -> str:
+        lines = [f"Task: {result.task}", f"Winner: {result.winner or 'N/A'}", ""]
+        for e in result.entries:
+            status = "OK" if e.success else f"FAIL: {e.error}"
+            lines.append(f"  {e.model}: {e.duration_s:.1f}s, {e.token_count}t — {status}")
+        return "\n".join(lines)