continuous-refactoring 0.1.0__py3-none-any.whl

continuous_refactoring/commit_messages.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from continuous_refactoring.decisions import AgentStatus, sanitize_text
+
+__all__ = [
+    "build_commit_message",
+    "commit_rationale",
+]
+
+_EMPTY_VALUES = frozenset({"none", "n/a", "na"})
+_PLACEHOLDER_SUMMARIES = frozenset(
+    {
+        "ready to commit",
+        "validated refactor ready to commit",
+    }
+)
+
+
+def _normalized_value(text: str) -> str:
+    return text.lower().rstrip(".")
+
+
+def _present_text(text: str | None) -> str | None:
+    if text is None:
+        return None
+    stripped = text.strip()
+    if not stripped or _normalized_value(stripped) in _EMPTY_VALUES:
+        return None
+    return stripped
+
+
+def commit_rationale(
+    status: AgentStatus | None,
+    *,
+    fallback: str,
+    repo_root: Path,
+) -> str:
+    if status is not None:
+        rationale = _present_text(sanitize_text(status.commit_rationale, repo_root))
+        if rationale is not None:
+            return rationale
+
+        summary = _present_text(sanitize_text(status.summary, repo_root))
+        if (
+            summary is not None
+            and _normalized_value(summary) not in _PLACEHOLDER_SUMMARIES
+        ):
+            return summary
+
+    fallback_text = _present_text(sanitize_text(fallback, repo_root))
+    if fallback_text is not None:
+        return fallback_text
+    return "Validated cleanup completed."
+
+
+def build_commit_message(
+    subject: str,
+    *,
+    why: str,
+    validation: str | None = None,
+) -> str:
+    sections = [f"Why:\n{why.strip()}"]
+    validation_text = _present_text(validation)
+    if validation_text is not None:
+        sections.append(f"Validation:\n{validation_text}")
+    return f"{subject.strip()}\n\n" + "\n\n".join(sections)

continuous_refactoring/config.py

@@ -0,0 +1,377 @@
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import tempfile
+import uuid
+from dataclasses import asdict, dataclass, replace
+from datetime import datetime
+from pathlib import Path
+from collections.abc import Mapping
+
+from continuous_refactoring.artifacts import ContinuousRefactorError
+
+__all__ = [
+    "CONFIG_CURRENT_VERSION",
+    "ProjectEntry",
+    "ResolvedProject",
+    "TASTE_CURRENT_VERSION",
+    "app_data_dir",
+    "config_is_current",
+    "default_taste_text",
+    "ensure_taste_file",
+    "failure_snapshots_dir",
+    "find_project",
+    "global_dir",
+    "load_config_version",
+    "load_manifest",
+    "load_taste",
+    "manifest_path",
+    "parse_taste_version",
+    "register_project",
+    "resolve_live_migrations_dir",
+    "resolve_project",
+    "save_manifest",
+    "set_live_migrations_dir",
+    "taste_is_stale",
+    "xdg_data_home",
+]
+
+CONFIG_CURRENT_VERSION = 1
+TASTE_CURRENT_VERSION = 1
+
+_DEFAULT_TASTE = """\
+taste-scoping-version: 1
+
+- Validate at the edges and stay lean in the middle.
+- Keep exception translation only at real boundaries and preserve causes when translating.
+- Keep comments only when they explain a real boundary contract or a genuinely deferred design issue that code alone cannot make obvious.
+- Remove fallback, compat, adapter, migrated, legacy, or normalize-shaped code when evidence shows it is no longer needed.
+- Merge modules when splits hurt locality more than they help. Split modules when one file hides unrelated responsibilities.
+
+## large-scope decisions
+- When to split a module vs. unify related modules.
+- When to introduce or remove an interface or abstraction boundary.
+- When a cross-cutting concern warrants a shared library vs. inline duplication.
+
+## rollout style
+- Caution level for changes with wide blast radius.
+- Feature-flag user-visible behavior changes before full rollout.
+- Prefer incremental, reviewable steps over large-bang rewrites.
+"""
+
+
+@dataclass(frozen=True)
+class ProjectEntry:
+    uuid: str
+    path: str
+    git_remote: str | None
+    created_at: str
+    live_migrations_dir: str | None = None
+
+
+@dataclass(frozen=True)
+class ResolvedProject:
+    entry: ProjectEntry
+    project_dir: Path
+
+
+# ---------------------------------------------------------------------------
+# Path helpers
+# ---------------------------------------------------------------------------
+
+def xdg_data_home() -> Path:
+    env = os.environ.get("XDG_DATA_HOME")
+    if env:
+        return Path(env)
+    return Path.home() / ".local" / "share"
+
+
+def app_data_dir() -> Path:
+    return xdg_data_home() / "continuous-refactoring"
+
+
+def global_dir() -> Path:
+    return app_data_dir() / "global"
+
+
+def manifest_path() -> Path:
+    return app_data_dir() / "manifest.json"
+
+
+# ---------------------------------------------------------------------------
+# Manifest I/O
+# ---------------------------------------------------------------------------
+
+def _load_manifest_payload() -> dict[str, object]:
+    path = manifest_path()
+    if not path.exists():
+        return {}
+    raw_text = _read_manifest_text()
+    return _parse_manifest_payload(raw_text)
+
+
+def _read_manifest_text() -> str:
+    try:
+        return manifest_path().read_text(encoding="utf-8")
+    except OSError as exc:
+        raise ContinuousRefactorError(
+            "Manifest file could not be read."
+        ) from exc
+
+
+def _parse_manifest_payload(text: str) -> dict[str, object]:
+    try:
+        raw = json.loads(text)
+    except json.JSONDecodeError as exc:
+        raise ContinuousRefactorError(
+            "Manifest file is malformed: invalid JSON."
+        ) from exc
+    if not isinstance(raw, dict):
+        raise ContinuousRefactorError(
+            "Manifest file is malformed: expected a JSON object."
+        )
+    return raw
+
+
+def _string_field(
+    data: Mapping[str, object],
+    key: str,
+    *,
+    project_id: str,
+    required: bool,
+) -> str | None:
+    value = data.get(key)
+    if value is None:
+        if required:
+            raise ContinuousRefactorError(
+                f"Manifest file is malformed: project '{project_id}' missing '{key}'."
+            )
+        return None
+    if not isinstance(value, str):
+        raise ContinuousRefactorError(
+            f"Manifest file is malformed: project '{project_id}' field '{key}' must be a string."
+        )
+    return value
+
+
+def _entry_from_object(uid: str, data: object) -> ProjectEntry:
+    if not isinstance(data, dict):
+        raise ContinuousRefactorError(
+            f"Manifest file is malformed: project '{uid}' must be a JSON object."
+        )
+    entry_uuid = _string_field(data, "uuid", project_id=uid, required=True)
+    if entry_uuid != uid:
+        raise ContinuousRefactorError(
+            f"Manifest file is malformed: project '{uid}' uuid mismatch."
+        )
+    return ProjectEntry(
+        uuid=entry_uuid,
+        path=_string_field(data, "path", project_id=uid, required=True),
+        git_remote=_string_field(
+            data,
+            "git_remote",
+            project_id=uid,
+            required=False,
+        ),
+        created_at=_string_field(data, "created_at", project_id=uid, required=True),
+        live_migrations_dir=_string_field(
+            data,
+            "live_migrations_dir",
+            project_id=uid,
+            required=False,
+        ),
+    )
+
+
+def load_manifest() -> dict[str, ProjectEntry]:
+    payload = _load_manifest_payload()
+    projects_raw = payload.get("projects", {})
+    if not isinstance(projects_raw, dict):
+        raise ContinuousRefactorError(
+            "Manifest file is malformed: 'projects' must be a JSON object."
+        )
+    return {uid: _entry_from_object(uid, entry) for uid, entry in projects_raw.items()}
+
+
+def save_manifest(manifest: dict[str, ProjectEntry]) -> None:
+    path = manifest_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    payload = {
+        "version": CONFIG_CURRENT_VERSION,
+        "projects": {uid: asdict(entry) for uid, entry in manifest.items()},
+    }
+    content = json.dumps(payload, indent=2, sort_keys=True) + "\n"
+    fd, tmp = tempfile.mkstemp(dir=str(path.parent), suffix=".tmp")
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as fh:
+            fh.write(content)
+        os.replace(tmp, str(path))
+    except Exception:
+        if os.path.exists(tmp):
+            os.unlink(tmp)
+        raise
+
+
+def load_config_version() -> int | None:
+    payload = _load_manifest_payload()
+    version = payload.get("version")
+    return version if isinstance(version, int) else None
+
+
+def config_is_current() -> bool:
+    return load_config_version() == CONFIG_CURRENT_VERSION
+
+
+# ---------------------------------------------------------------------------
+# Project lookup / registration
+# ---------------------------------------------------------------------------
+
+def find_project(
+    path: Path, manifest: dict[str, ProjectEntry]
+) -> ProjectEntry | None:
+    for entry in manifest.values():
+        if _project_path_matches(path, entry.path):
+            return entry
+    return None
+
+
+def _project_path_matches(path: Path, stored_path: str) -> bool:
+    return path.resolve() == Path(stored_path).resolve()
+
+
+def _detect_git_remote(path: Path) -> str | None:
+    try:
+        result = subprocess.run(
+            ["git", "remote", "get-url", "origin"],
+            cwd=path,
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+    except FileNotFoundError:
+        return None
+    if result.returncode != 0:
+        return None
+    return result.stdout.strip() or None
+
+
+def _resolved(entry: ProjectEntry) -> ResolvedProject:
+    project_dir = app_data_dir() / "projects" / entry.uuid
+    project_dir.mkdir(parents=True, exist_ok=True)
+    return ResolvedProject(entry=entry, project_dir=project_dir)
+
+
+def failure_snapshots_dir(path: Path) -> Path:
+    snapshot_dir = register_project(path).project_dir / "failures"
+    snapshot_dir.mkdir(parents=True, exist_ok=True)
+    return snapshot_dir
+
+
+def register_project(path: Path) -> ResolvedProject:
+    resolved = path.resolve()
+    manifest = load_manifest()
+    existing = find_project(resolved, manifest)
+    if existing is not None:
+        return _resolved(existing)
+
+    uid = str(uuid.uuid4())
+    entry = ProjectEntry(
+        uuid=uid,
+        path=str(resolved),
+        git_remote=_detect_git_remote(resolved),
+        created_at=datetime.now().astimezone().isoformat(timespec="milliseconds"),
+    )
+    manifest[uid] = entry
+    save_manifest(manifest)
+    return _resolved(entry)
+
+
+def resolve_project(path: Path) -> ResolvedProject:
+    manifest = load_manifest()
+    entry = find_project(path, manifest)
+    if entry is None:
+        raise ContinuousRefactorError(
+            f"Project not registered: {path.resolve()}"
+        )
+    return _resolved(entry)
+
+
+def resolve_live_migrations_dir(project: ResolvedProject) -> Path | None:
+    if project.entry.live_migrations_dir is None:
+        return None
+    repo_root = Path(project.entry.path)
+    resolved = (repo_root / project.entry.live_migrations_dir).resolve()
+    if not resolved.is_relative_to(repo_root):
+        raise ContinuousRefactorError(
+            f"live_migrations_dir escapes repo: {project.entry.live_migrations_dir}"
+        )
+    return resolved
+
+
+def _get_project(manifest: dict[str, ProjectEntry], project_uuid: str) -> ProjectEntry:
+    project = manifest.get(project_uuid)
+    if project is None:
+        raise ContinuousRefactorError(f"Project not registered: {project_uuid}")
+    return project
+
+
+def set_live_migrations_dir(project_uuid: str, relative_dir: str) -> None:
+    manifest = load_manifest()
+    old = _get_project(manifest, project_uuid)
+    manifest[project_uuid] = replace(old, live_migrations_dir=relative_dir)
+    save_manifest(manifest)
+
+
+# ---------------------------------------------------------------------------
+# Taste
+# ---------------------------------------------------------------------------
+
+def parse_taste_version(text: str) -> int | None:
+    first_line = text.split("\n", 1)[0].strip()
+    prefix = "taste-scoping-version:"
+    if not first_line.startswith(prefix):
+        return None
+    raw = first_line[len(prefix):].strip()
+    try:
+        return int(raw)
+    except ValueError:
+        return None
+
+
+def taste_is_stale(text: str) -> bool:
+    return parse_taste_version(text) != TASTE_CURRENT_VERSION
+
+
+def default_taste_text() -> str:
+    return _DEFAULT_TASTE
+
+
+def ensure_taste_file(path: Path) -> Path:
+    if not path.exists():
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(_DEFAULT_TASTE, encoding="utf-8")
+    return path
+
+
+def _read_taste_text(path: Path) -> str:
+    try:
+        return path.read_text(encoding="utf-8")
+    except OSError as exc:
+        raise ContinuousRefactorError(
+            f"Taste file could not be read: {path}"
+        ) from exc
+
+
+def load_taste(project: ResolvedProject | None) -> str:
+    if project is not None:
+        project_taste = project.project_dir / "taste.md"
+        if project_taste.exists():
+            return _read_taste_text(project_taste)
+
+    global_taste = global_dir() / "taste.md"
+    if global_taste.exists():
+        return _read_taste_text(global_taste)
+
+    return _DEFAULT_TASTE

continuous_refactoring/decisions.py

@@ -0,0 +1,197 @@
+"""Agent status types and decision records."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal, get_args
+
+from continuous_refactoring.prompts import (
+    CONTINUOUS_REFACTORING_STATUS_BEGIN,
+    CONTINUOUS_REFACTORING_STATUS_END,
+)
+
+__all__ = [
+    "AgentStatus",
+    "DecisionRecord",
+    "RouteOutcome",
+    "RunnerDecision",
+    "RetryRecommendation",
+    "default_retry_recommendation",
+    "error_failure_kind",
+    "parse_status_block",
+    "read_status",
+    "resolved_phase_reached",
+    "sanitize_text",
+    "status_summary",
+]
+
+
+RunnerDecision = Literal["commit", "retry", "abandon", "blocked"]
+RetryRecommendation = Literal["same-target", "new-target", "none", "human-review"]
+RouteOutcome = Literal["not-routed", "commit", "abandon", "blocked"]
+
+_VALID_DECISIONS = frozenset((*get_args(RunnerDecision), None))
+_VALID_RETRY_RECOMMENDATIONS = frozenset(
+    (*get_args(RetryRecommendation), None),
+)
+
+
+@dataclass(frozen=True)
+class AgentStatus:
+    phase_reached: str | None = None
+    decision: RunnerDecision | None = None
+    retry_recommendation: RetryRecommendation | None = None
+    failure_kind: str | None = None
+    summary: str | None = None
+    commit_rationale: str | None = None
+    next_retry_focus: str | None = None
+    tests_run: str | None = None
+    evidence: tuple[str, ...] = ()
+
+
+@dataclass(frozen=True)
+class DecisionRecord:
+    decision: RunnerDecision
+    retry_recommendation: RetryRecommendation
+    target: str
+    call_role: str
+    phase_reached: str
+    failure_kind: str
+    summary: str
+    next_retry_focus: str | None = None
+    retry_used: int = 1
+    agent_last_message_path: Path | None = None
+    agent_stdout_path: Path | None = None
+    agent_stderr_path: Path | None = None
+    tests_stdout_path: Path | None = None
+    tests_stderr_path: Path | None = None
+
+
+def _status_path_text(path: Path | None) -> str | None:
+    if path is None or not path.exists():
+        return None
+    return path.read_text(encoding="utf-8")
+
+
+def parse_status_block(text: str | None) -> AgentStatus | None:
+    if not text:
+        return None
+    begin = text.rfind(CONTINUOUS_REFACTORING_STATUS_BEGIN)
+    if begin < 0:
+        return None
+    end = text.find(CONTINUOUS_REFACTORING_STATUS_END, begin)
+    if end < 0:
+        return None
+    block = text[begin + len(CONTINUOUS_REFACTORING_STATUS_BEGIN):end].strip()
+    if not block:
+        return None
+
+    data: dict[str, str] = {}
+    evidence: list[str] = []
+    current_key: str | None = None
+    for raw_line in block.splitlines():
+        line = raw_line.strip()
+        if not line:
+            continue
+        if current_key == "evidence" and line.startswith("- "):
+            evidence.append(line[2:].strip())
+            continue
+        if ":" not in line:
+            continue
+        key, value = line.split(":", 1)
+        current_key = key.strip()
+        if current_key == "evidence":
+            if value.strip():
+                evidence.append(value.strip())
+            continue
+        data[current_key] = value.strip()
+
+    decision = data.get("decision", "").lower() or None
+    if decision not in _VALID_DECISIONS:
+        decision = None
+    retry_recommendation = data.get("retry_recommendation", "").lower() or None
+    if retry_recommendation not in _VALID_RETRY_RECOMMENDATIONS:
+        retry_recommendation = None
+
+    return AgentStatus(
+        phase_reached=data.get("phase_reached") or None,
+        decision=decision,
+        retry_recommendation=retry_recommendation,
+        failure_kind=data.get("failure_kind") or None,
+        summary=data.get("summary") or None,
+        commit_rationale=data.get("commit_rationale") or None,
+        next_retry_focus=data.get("next_retry_focus") or None,
+        tests_run=data.get("tests_run") or None,
+        evidence=tuple(evidence),
+    )
+
+
+def read_status(
+    agent: str,
+    *,
+    last_message_path: Path | None,
+    fallback_text: str | None,
+) -> AgentStatus | None:
+    if agent == "codex":
+        status = parse_status_block(_status_path_text(last_message_path))
+        if status is not None:
+            return status
+    return parse_status_block(fallback_text)
+
+
+def sanitize_text(text: str | None, repo_root: Path) -> str | None:
+    if not text:
+        return None
+    lines: list[str] = []
+    for raw_line in text.splitlines():
+        line = raw_line.strip()
+        if not line or "codex exec" in line:
+            continue
+        line = line.replace(str(repo_root), "<repo>")
+        line = re.sub(r"/tmp/[^ ]+", "<tmp>", line)
+        line = re.sub(r"\s+", " ", line).strip()
+        if line:
+            lines.append(line)
+    if not lines:
+        return None
+    return " ".join(lines)[:240]
+
+
+def status_summary(
+    status: AgentStatus | None,
+    *,
+    fallback: str,
+    repo_root: Path,
+) -> tuple[str, str | None]:
+    summary = sanitize_text(status.summary if status else None, repo_root) or fallback
+    focus = sanitize_text(status.next_retry_focus if status else None, repo_root)
+    return summary, focus
+
+
+def resolved_phase_reached(status: AgentStatus | None, fallback: str) -> str:
+    if status is None:
+        return fallback
+    return status.phase_reached or fallback
+
+
+def error_failure_kind(message: str) -> str:
+    lowered = message.lower()
+    if "timed out" in lowered:
+        return "timeout"
+    if "produced no output" in lowered:
+        return "stuck"
+    return "agent-infra-failure"
+
+
+def default_retry_recommendation(
+    decision: RunnerDecision,
+) -> RetryRecommendation:
+    if decision == "retry":
+        return "same-target"
+    if decision == "abandon":
+        return "new-target"
+    if decision == "blocked":
+        return "human-review"
+    return "none"