devflow-engine 1.0.0__py3-none-any.whl

devflow_engine/core/config.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+
+@dataclass(frozen=True)
+class EffectiveValue:
+    value: Any
+    source: str
+
+
+@dataclass(frozen=True)
+class DevflowConfig:
+    log_level: str = "INFO"
+    api_key: str | None = None
+
+
+def _read_yaml_file(path: Path) -> dict[str, Any]:
+    try:
+        raw = yaml.safe_load(path.read_text(encoding="utf-8"))
+    except FileNotFoundError:
+        return {}
+    except Exception:
+        # Non-fatal for bootstrap; treat as absent.
+        return {}
+    if raw is None:
+        return {}
+    if not isinstance(raw, dict):
+        return {}
+    return raw
+
+
+def load_effective_config(
+    *,
+    config_file: Path | None,
+    env: dict[str, str] | None = None,
+    cli_log_level: str | None = None,
+) -> tuple[DevflowConfig, dict[str, EffectiveValue]]:
+    """Load config with precedence defaults < file < env < cli.
+
+    Returns (config, meta) where meta contains per-field source/value.
+    """
+
+    env = dict(os.environ) if env is None else env
+
+    # Defaults
+    data: dict[str, EffectiveValue] = {
+        "log_level": EffectiveValue("INFO", "default"),
+        "api_key": EffectiveValue(None, "default"),
+    }
+
+    # File
+    if config_file is not None:
+        file_data = _read_yaml_file(config_file)
+        if "log_level" in file_data and isinstance(file_data["log_level"], str):
+            data["log_level"] = EffectiveValue(file_data["log_level"], f"file:{config_file}")
+        if "api_key" in file_data and isinstance(file_data["api_key"], str):
+            data["api_key"] = EffectiveValue(file_data["api_key"], f"file:{config_file}")
+
+    # Env
+    if (lvl := env.get("DEVFLOW_ENGINE_LOG_LEVEL")):
+        data["log_level"] = EffectiveValue(lvl, "env:DEVFLOW_ENGINE_LOG_LEVEL")
+    if (key := env.get("DEVFLOW_ENGINE_API_KEY")):
+        data["api_key"] = EffectiveValue(key, "env:DEVFLOW_ENGINE_API_KEY")
+
+    # CLI
+    if cli_log_level:
+        data["log_level"] = EffectiveValue(cli_log_level, "cli:--log-level")
+
+    cfg = DevflowConfig(log_level=str(data["log_level"].value), api_key=data["api_key"].value)
+    return cfg, data
+
+
+def redact_value(key: str, value: Any) -> str:
+    if value is None:
+        return "<unset>"
+
+    k = key.lower()
+    if any(tok in k for tok in ["key", "token", "secret", "password"]):
+        return "***"
+    return str(value)

devflow_engine/core/logging.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+from rich.logging import RichHandler
+
+
+def configure_logging(log_dir: Path | None, level: str = "INFO") -> None:
+    """Configure console + optional file logging."""
+    handlers: list[logging.Handler] = [
+        RichHandler(rich_tracebacks=True, show_time=True, show_level=True, show_path=False)
+    ]
+
+    if log_dir is not None:
+        log_dir.mkdir(parents=True, exist_ok=True)
+        file_path = log_dir / "devflow.log"
+        file_handler = logging.FileHandler(file_path)
+        file_handler.setFormatter(
+            logging.Formatter("%(asctime)s %(levelname)s %(name)s %(message)s")
+        )
+        handlers.append(file_handler)
+
+    logging.basicConfig(
+        level=getattr(logging, level.upper(), logging.INFO),
+        format="%(message)s",
+        datefmt="[%X]",
+        handlers=handlers,
+    )

devflow_engine/core/paths.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class DevflowPaths:
+    root: Path
+
+    @property
+    def devflow_dir(self) -> Path:
+        return self.root / ".devflow"
+
+    @property
+    def execution_db(self) -> Path:
+        return self.devflow_dir / "execution.sqlite"
+
+    @property
+    def projects_dir(self) -> Path:
+        return self.devflow_dir / "projects"
+
+    @property
+    def stories_dir(self) -> Path:
+        return self.devflow_dir / "stories"
+
+    @property
+    def logs_dir(self) -> Path:
+        return self.devflow_dir / "logs"
+
+
+def find_repo_root(start: Path | None = None) -> Path:
+    """Find the repo root (directory containing .git) walking upwards.
+
+    Falls back to current working directory if no .git found.
+    """
+    here = (start or Path.cwd()).resolve()
+    for p in [here, *here.parents]:
+        if (p / ".git").exists():
+            return p
+    return here
+
+
+def get_paths(start: Path | None = None) -> DevflowPaths:
+    return DevflowPaths(root=find_repo_root(start))

devflow_engine/core/toml_kv.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+
+def _toml_quote(s: str) -> str:
+    # Minimal TOML basic string quoting.
+    return '"' + s.replace('\\', '\\\\').replace('"', '\\"') + '"'
+
+
+def write_toml_kv(path: Path, data: dict[str, Any]) -> None:
+    """Write a minimal TOML file for flat key/value pairs.
+
+    This intentionally supports only string/int/bool keys at the top level.
+    Good enough for devflow global config without bringing in a toml writer dep.
+    """
+
+    lines: list[str] = []
+    for k in sorted(data.keys()):
+        v = data[k]
+        if isinstance(v, bool):
+            vv = "true" if v else "false"
+        elif isinstance(v, int):
+            vv = str(v)
+        elif v is None:
+            continue
+        else:
+            vv = _toml_quote(str(v))
+        lines.append(f"{k} = {vv}")
+
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text("\n".join(lines) + "\n", encoding="utf-8")