devflow-engine 1.1.26__tar.gz → 1.2.0__tar.gz

devflow_engine-1.2.0/.gitignore

@@ -0,0 +1,8 @@
+.venv/
+.devflow/
+.pytest_cache/
+__pycache__/
+*.py[cod]
+dist/
+build/
+*.egg-info/

devflow_engine-1.2.0/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: devflow-engine
+Version: 1.2.0
+Summary: DevFlow Engine 1.2 rebuild CLI
+Author: DevFlow
+License: Proprietary
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.28
+Requires-Dist: keyring>=25.0
+Requires-Dist: pydantic>=2.6
+Requires-Dist: typer>=0.12
+Description-Content-Type: text/markdown
+
+# DevFlow Engine
+
+DevFlow Engine 1.2 rebuild workspace.
+
+This package starts from the public CLI boundary and ports runtime behavior only after tests define the contract for each primitive.

devflow_engine-1.2.0/README.md

@@ -0,0 +1,5 @@
+# DevFlow Engine
+
+DevFlow Engine 1.2 rebuild workspace.
+
+This package starts from the public CLI boundary and ports runtime behavior only after tests define the contract for each primitive.

devflow_engine-1.2.0/pyproject.toml

@@ -0,0 +1,34 @@
+[project]
+name = "devflow-engine"
+version = "1.2.0"
+description = "DevFlow Engine 1.2 rebuild CLI"
+readme = "README.md"
+requires-python = ">=3.11"
+authors = [{ name = "DevFlow" }]
+license = { text = "Proprietary" }
+dependencies = [
+  "httpx>=0.28",
+  "keyring>=25.0",
+  "pydantic>=2.6",
+  "typer>=0.12",
+]
+
+[dependency-groups]
+dev = [
+  "pytest>=8.0",
+]
+
+[project.scripts]
+devflow = "devflow_engine.cli.app:app"
+devflow-engine = "devflow_engine.cli.app:app"
+
+[build-system]
+requires = ["hatchling>=1.24"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/devflow_engine"]
+
+[tool.pytest.ini_options]
+addopts = "-q"
+testpaths = ["tests"]

devflow_engine-1.2.0/src/devflow_engine/__init__.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+__all__ = ["__version__"]
+
+__version__ = "1.2.0"

devflow_engine-1.2.0/src/devflow_engine/agentic/__init__.py

@@ -0,0 +1 @@
+from __future__ import annotations

devflow_engine-1.2.0/src/devflow_engine/agentic/service.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import Any
+
+from pydantic import BaseModel, ValidationError
+
+from devflow_engine.llm.provider_service import (
+    CredentialResolver,
+    LlmProviderService,
+    LlmSettings,
+    ProviderTransport,
+    TierName,
+)
+
+
+class AgenticServiceError(RuntimeError):
+    pass
+
+
+@dataclass(frozen=True)
+class AgenticInvocation:
+    purpose: str
+    tier: TierName
+    system_prompt: str
+    context: dict[str, Any]
+    output_model: type[BaseModel]
+
+
+@dataclass(frozen=True)
+class AgenticResult:
+    output: BaseModel
+    raw_response: dict[str, Any]
+
+
+class AgenticService:
+    def __init__(self, *, llm: LlmProviderService) -> None:
+        self.llm = llm
+
+    @classmethod
+    def for_settings(
+        cls,
+        *,
+        settings: LlmSettings,
+        credential_resolver: CredentialResolver,
+        transport: ProviderTransport,
+    ) -> "AgenticService":
+        return cls(
+            llm=LlmProviderService(
+                settings=settings,
+                credential_resolver=credential_resolver,
+                transport=transport,
+            )
+        )
+
+    def run(self, invocation: AgenticInvocation) -> AgenticResult:
+        messages = [
+            {
+                "role": "system",
+                "content": (
+                    invocation.system_prompt
+                    + "\nReturn JSON only matching this schema:\n"
+                    + json.dumps(invocation.output_model.model_json_schema(), sort_keys=True)
+                ),
+            },
+            {
+                "role": "user",
+                "content": json.dumps(invocation.context, indent=2, sort_keys=True),
+            },
+        ]
+        raw_response = self.llm.invoke(
+            tier=invocation.tier,
+            purpose=invocation.purpose,
+            messages=messages,
+            response_format="json",
+        )
+        content = str(raw_response.get("content") or "").strip()
+        try:
+            payload = json.loads(content)
+        except json.JSONDecodeError as exc:
+            raise AgenticServiceError(f"failed to parse JSON response: {exc}") from exc
+        try:
+            output = invocation.output_model.model_validate(payload)
+        except ValidationError as exc:
+            raise AgenticServiceError(f"failed output model validation: {exc}") from exc
+        return AgenticResult(output=output, raw_response=raw_response)

devflow_engine-1.2.0/src/devflow_engine/agentic/tier_config.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+from devflow_engine.llm.provider_capabilities import AuthType, ProviderName
+from devflow_engine.llm.provider_service import LlmSettings, ReasoningLevel, TierName
+
+
+def default_agentic_tier_settings() -> LlmSettings:
+    return LlmSettings.model_validate(
+        {
+            "tiers": {
+                "ultra_light": {
+                    "provider": "ollama",
+                    "model": "llama3.2",
+                    "reasoning": "none",
+                    "auth_type": "local",
+                },
+                "light": {
+                    "provider": "openai",
+                    "model": "default",
+                    "reasoning": "low",
+                    "auth_type": "subscription",
+                },
+                "standard": {
+                    "provider": "anthropic",
+                    "model": "sonnet",
+                    "reasoning": "medium",
+                    "auth_type": "subscription",
+                },
+                "strong": {
+                    "provider": "anthropic",
+                    "model": "sonnet",
+                    "reasoning": "high",
+                    "auth_type": "subscription",
+                },
+            }
+        }
+    )
+
+
+def default_agentic_tier_config_path() -> Path:
+    config_home = Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config"))
+    return config_home / "devflow-engine" / "agentic-tiers.json"
+
+
+class AgenticTierConfigStore:
+    def __init__(self, *, path: Path | None = None) -> None:
+        self.path = path or default_agentic_tier_config_path()
+
+    def load(self) -> LlmSettings:
+        if not self.path.exists():
+            return default_agentic_tier_settings()
+        return LlmSettings.model_validate_json(self.path.read_text())
+
+    def save(self, settings: LlmSettings) -> LlmSettings:
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self.path.write_text(settings.model_dump_json(indent=2, exclude_none=False) + "\n")
+        return settings
+
+    def set_tier(
+        self,
+        *,
+        tier: TierName,
+        provider: ProviderName,
+        auth_type: AuthType,
+        model: str,
+        reasoning: ReasoningLevel = "medium",
+        endpoint: str | None = None,
+    ) -> LlmSettings:
+        current = self.load().model_dump(mode="json")
+        current["tiers"][tier] = {
+            "provider": provider,
+            "model": model,
+            "reasoning": reasoning,
+            "auth_type": auth_type,
+            "endpoint": endpoint,
+        }
+        settings = LlmSettings.model_validate(current)
+        return self.save(settings)
+
+    def reset(self) -> LlmSettings:
+        if self.path.exists():
+            self.path.unlink()
+        return default_agentic_tier_settings()

devflow_engine-1.2.0/src/devflow_engine/agentic/tier_verifier.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+import json
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+from devflow_engine.llm.provider_service import CredentialResolver, LlmProviderService, LlmSettings, ProviderTransport, TierName
+
+
+class TierVerificationError(RuntimeError):
+    pass
+
+
+class TierVerificationService:
+    def __init__(
+        self,
+        *,
+        settings: LlmSettings,
+        credential_resolver: CredentialResolver,
+        transport: ProviderTransport,
+    ) -> None:
+        self.settings = settings
+        self.credential_resolver = credential_resolver
+        self.transport = transport
+
+    def verify(self, *, tiers: list[TierName], output_path: Path) -> dict[str, Any]:
+        service = LlmProviderService(
+            settings=self.settings,
+            credential_resolver=self.credential_resolver,
+            transport=self.transport,
+        )
+        artifact: dict[str, Any] = {
+            "created_at": datetime.now(UTC).isoformat(),
+            "records": [],
+        }
+        failed = False
+        for tier in tiers:
+            config = service.config_for_tier(tier)
+            record: dict[str, Any] = {
+                "tier": tier,
+                "provider": config.provider,
+                "model": config.model,
+                "reasoning": config.reasoning,
+                "auth_type": config.auth_type,
+                "ok": False,
+            }
+            try:
+                response = service.invoke(
+                    tier=tier,
+                    purpose="agentic.tier.verify",
+                    messages=[
+                        {
+                            "role": "user",
+                            "content": (
+                                "DevFlow tier verification. Reply with one short sentence naming the model "
+                                "or runtime you are using."
+                            ),
+                        }
+                    ],
+                    response_format="text",
+                )
+                record["ok"] = True
+                record["response"] = str(response.get("content") or "")
+                record["raw_response"] = response
+            except Exception as exc:  # noqa: BLE001 - artifact must preserve provider/auth failures.
+                failed = True
+                record["error"] = str(exc)
+            artifact["records"].append(record)
+
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        output_path.write_text(json.dumps(artifact, indent=2) + "\n")
+        if failed:
+            raise TierVerificationError(f"tier verification failed; artifact written to {output_path}")
+        return artifact
+
+
+class ChainedCredentialResolver:
+    def __init__(self, resolvers: list[CredentialResolver]) -> None:
+        self.resolvers = resolvers
+
+    def resolve(self, *, provider, auth_type):
+        for resolver in self.resolvers:
+            material = resolver.resolve(provider=provider, auth_type=auth_type)
+            if material is not None:
+                return material
+        return None
+
+
+class AuthRoutingTransport:
+    def __init__(self, *, api_transport: ProviderTransport, subscription_transport: ProviderTransport) -> None:
+        self.api_transport = api_transport
+        self.subscription_transport = subscription_transport
+
+    def invoke(self, request):
+        if request.auth.auth_type == "subscription":
+            return self.subscription_transport.invoke(request)
+        return self.api_transport.invoke(request)
+
+
+def default_tier_verification_output_path() -> Path:
+    stamp = datetime.now(UTC).strftime("%Y%m%dT%H%M%SZ")
+    return Path(".devflow") / "runs" / f"agentic-tier-verification-{stamp}.json"

devflow_engine-1.2.0/src/devflow_engine/auth/__init__.py

@@ -0,0 +1,3 @@
+from devflow_engine.auth.keychain import KeychainCredentialResolver, KeychainSecretRef, KeychainSecretStatus, KeychainSecretStore
+
+__all__ = ["KeychainCredentialResolver", "KeychainSecretRef", "KeychainSecretStatus", "KeychainSecretStore"]

devflow_engine-1.2.0/src/devflow_engine/auth/keychain.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+from typing import Protocol
+
+import keyring
+from keyring.errors import PasswordDeleteError
+from pydantic import BaseModel, ConfigDict, field_validator, model_validator
+
+from devflow_engine.llm.provider_service import AuthMaterial, AuthType, ProviderName, validate_provider_auth
+
+
+DEFAULT_SERVICE_NAME = "devflow-engine"
+
+
+class KeyringBackend(Protocol):
+    def set_password(self, service_name: str, username: str, password: str) -> None: ...
+
+    def get_password(self, service_name: str, username: str) -> str | None: ...
+
+    def delete_password(self, service_name: str, username: str) -> None: ...
+
+
+class KeychainSecretRef(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    provider: ProviderName
+    auth_type: AuthType
+
+    @field_validator("provider", "auth_type", mode="before")
+    @classmethod
+    def _normalize_text(cls, value: object) -> str:
+        return str(value or "").strip().lower()
+
+    @model_validator(mode="after")
+    def _provider_auth_pair_must_be_supported(self) -> "KeychainSecretRef":
+        validate_provider_auth(self.provider, self.auth_type)
+        return self
+
+    @property
+    def account(self) -> str:
+        return f"llm:{self.provider}:{self.auth_type}"
+
+
+class KeychainSecretStatus(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    provider: ProviderName
+    auth_type: AuthType
+    configured: bool
+    service_name: str
+    account: str
+
+
+class KeychainSecretStore:
+    def __init__(
+        self,
+        *,
+        service_name: str = DEFAULT_SERVICE_NAME,
+        keyring_backend: KeyringBackend = keyring,
+    ) -> None:
+        self.service_name = service_name
+        self.keyring_backend = keyring_backend
+
+    def set_secret(self, ref: KeychainSecretRef, secret: str) -> None:
+        normalized_secret = secret.strip()
+        if not normalized_secret:
+            raise ValueError("secret cannot be empty")
+        self.keyring_backend.set_password(self.service_name, ref.account, normalized_secret)
+
+    def get_secret(self, ref: KeychainSecretRef) -> str | None:
+        return self.keyring_backend.get_password(self.service_name, ref.account)
+
+    def delete_secret(self, ref: KeychainSecretRef) -> None:
+        try:
+            self.keyring_backend.delete_password(self.service_name, ref.account)
+        except PasswordDeleteError:
+            return
+
+    def status(self, ref: KeychainSecretRef) -> KeychainSecretStatus:
+        return KeychainSecretStatus(
+            provider=ref.provider,
+            auth_type=ref.auth_type,
+            configured=self.get_secret(ref) is not None,
+            service_name=self.service_name,
+            account=ref.account,
+        )
+
+
+class KeychainCredentialResolver:
+    def __init__(self, store: KeychainSecretStore | None = None) -> None:
+        self.store = store or KeychainSecretStore()
+
+    def resolve(self, *, provider: ProviderName, auth_type: AuthType) -> AuthMaterial | None:
+        if auth_type == "local":
+            return AuthMaterial(auth_type="local")
+        ref = KeychainSecretRef(provider=provider, auth_type=auth_type)
+        secret = self.store.get_secret(ref)
+        if secret is None:
+            return None
+        return AuthMaterial(
+            auth_type=auth_type,
+            secret=secret,
+            metadata={"source": "keychain", "service_name": self.store.service_name, "account": ref.account},
+        )

devflow_engine-1.2.0/src/devflow_engine/cli/__init__.py

@@ -0,0 +1 @@
+from __future__ import annotations