autodevloop 0.1.0__py3-none-any.whl

autodevloop/reporting.py

@@ -0,0 +1,127 @@
+"""Human-readable reports: CHANGELOG, FEATURES overview table, final report."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from .util import markdown_list, now_text, read_text, write_text
+
+
+def write_version_changelog(
+    changelog_path: Path,
+    version: int,
+    plan: dict[str, Any],
+    diff: dict[str, list[str]],
+    test_result: dict[str, Any],
+    review: dict[str, Any],
+    phase: str,
+) -> None:
+    if not changelog_path.exists():
+        write_text(changelog_path, "# Changelog\n\nAll AutoDevLoop-generated versions are recorded here.\n\n")
+
+    whats_new = review.get("whats_new") or []
+    summary = str(review.get("feature_summary") or plan.get("version_goal", "")).strip()
+    commands = ", ".join(test_result.get("commands", [])) or "No command"
+    lines = [
+        f"## v{version} - {now_text()}  ({phase} phase)",
+        "",
+        f"_{summary}_" if summary else "",
+        "",
+        "### What's new",
+        markdown_list(whats_new) if whats_new else markdown_list(diff.get("added", []) + diff.get("changed", [])),
+        "",
+        "### Files",
+        f"- Added: {len(diff.get('added', []))}, Changed: {len(diff.get('changed', []))}, Removed: {len(diff.get('removed', []))}",
+        "",
+        "### Tests",
+        f"- {'PASS' if test_result.get('success') else 'FAIL'}: {commands}",
+        "",
+        "### Known issues",
+        markdown_list(review.get("issues", [])),
+        "",
+    ]
+    existing = read_text(changelog_path)
+    write_text(changelog_path, existing.rstrip() + "\n\n" + "\n".join(line for line in lines) + "\n")
+
+
+def write_features_overview(features_path: Path, state: dict[str, Any]) -> None:
+    """The at-a-glance table: every version, its features, and what changed."""
+    versions = state.get("versions", [])
+    goal_version = state.get("goal_completed_version")
+    lines = [
+        "# Features Overview",
+        "",
+        f"**Project:** {state.get('project_name', '')}  ",
+        f"**Goal:** {state.get('goal', '')}",
+        "",
+    ]
+    if goal_version:
+        lines.append(f"> Core goal first fully met at **v{goal_version}** (tag `goal-complete`). "
+                     "Later versions extend the product beyond the original request.")
+        lines.append("")
+    lines += [
+        "| Version | Phase | Score | Tests | Summary | What's new |",
+        "|---|---|---|---|---|---|",
+    ]
+    for item in versions:
+        v = item.get("version")
+        phase = item.get("phase", "build")
+        score = item.get("review_score", "?")
+        tests = "✅" if item.get("test_result", {}).get("success") else "❌"
+        summary = _cell(item.get("feature_summary") or item.get("plan", {}).get("version_goal", ""))
+        whats_new = _cell("; ".join(item.get("whats_new", [])[:4]))
+        marker = " 🎯" if v == goal_version else ""
+        lines.append(f"| v{v}{marker} | {phase} | {score}/100 | {tests} | {summary} | {whats_new} |")
+    lines.append("")
+    write_text(features_path, "\n".join(lines))
+
+
+def _cell(text: str) -> str:
+    flat = " ".join(str(text).split())
+    flat = flat.replace("|", "\\|")
+    return flat[:160] + ("…" if len(flat) > 160 else "")
+
+
+def write_final_report(report_path: Path, state: dict[str, Any]) -> None:
+    versions = state.get("versions", [])
+    scores = [v.get("review_score", 0) for v in versions if isinstance(v.get("review_score", 0), int)]
+    avg = round(sum(scores) / len(scores)) if scores else 0
+    cost = state.get("cost", {})
+    lines = [
+        "# AutoDevLoop Final Report",
+        "",
+        f"**Project:** {state.get('project_name')}",
+        f"**Status:** {state.get('status')}",
+        f"**Stop reason:** {state.get('stop_reason', 'N/A')}",
+        f"**Total versions:** {state.get('current_version')}",
+        f"**Goal met at:** {('v' + str(state.get('goal_completed_version'))) if state.get('goal_completed_version') else 'not reached'}",
+        f"**Average review score:** {avg}/100",
+        f"**Estimated cost:** ${cost.get('cost_usd_total', 0):.4f} "
+        f"(in {cost.get('input_tokens', 0)} / out {cost.get('output_tokens', 0)} tokens)",
+        "",
+        "## Goal",
+        str(state.get("goal", "")),
+        "",
+        "## Version history",
+    ]
+    for item in versions:
+        v = item.get("version")
+        score = item.get("review_score", "?")
+        test = item.get("test_result", {})
+        phase = item.get("phase", "build")
+        lines.append(
+            f"- **v{v}** ({phase}) - score {score}/100 - tests "
+            f"{'PASS' if test.get('success') else 'FAIL'} - {_cell(item.get('feature_summary', ''))}"
+        )
+    lines += [
+        "",
+        "## Output layout",
+        "- Latest working copy: `current/`",
+        "- Per-version snapshots: `versions/vN/`",
+        "- Git history & tags inside `current/` (if git enabled)",
+        "- Changelog: `CHANGELOG.md`",
+        "- Features overview: `FEATURES.md`",
+        "",
+    ]
+    write_text(report_path, "\n".join(lines))

autodevloop/testing.py

@@ -0,0 +1,119 @@
+"""Built-in test detection and execution (no LLM required)."""
+
+from __future__ import annotations
+
+import re
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any
+
+from .util import INTERNAL_DIRS, list_generated_files, load_json, read_text
+
+
+def detect_candidates(base_dir: Path) -> list[dict[str, Any]]:
+    files = set(list_generated_files(base_dir))
+    candidates: list[dict[str, Any]] = []
+
+    if "package.json" in files:
+        package = load_json(base_dir / "package.json", {})
+        scripts = package.get("scripts", {}) if isinstance(package, dict) else {}
+        if "test" in scripts:
+            candidates.append({"name": "npm test", "command": "npm test", "kind": "node"})
+        if "build" in scripts:
+            candidates.append({"name": "npm run build", "command": "npm run build", "kind": "node"})
+
+    has_py_tests = any(f.startswith("tests/") and f.endswith(".py") for f in files) or any(
+        Path(f).name.startswith("test_") for f in files
+    )
+    if has_py_tests:
+        candidates.append({"name": "pytest", "command": "python -m pytest -q", "kind": "python"})
+        candidates.append({"name": "unittest", "command": "python -m unittest discover", "kind": "python"})
+
+    if "index.html" in files:
+        html = read_text(base_dir / "index.html")
+        candidates.append({"name": "static html smoke", "command": "__builtin_html_smoke__", "kind": "web"})
+        if 'type="module"' in html or "type='module'" in html:
+            candidates.append({"name": "module html server smoke", "command": "__builtin_html_server_smoke__", "kind": "web"})
+
+    if "pyproject.toml" in files or any(f.endswith(".py") for f in files):
+        candidates.append({"name": "python compile", "command": "__builtin_python_compile__", "kind": "python"})
+
+    candidates.append({"name": "file smoke", "command": "__builtin_file_smoke__", "kind": "generic"})
+    return candidates
+
+
+def run_command(base_dir: Path, command: str, timeout: int, log_path: Path) -> dict[str, Any]:
+    builtins = {
+        "__builtin_file_smoke__": _file_smoke,
+        "__builtin_html_smoke__": lambda d, t: _html_smoke(d, server=False),
+        "__builtin_html_server_smoke__": lambda d, t: _html_smoke(d, server=True),
+        "__builtin_python_compile__": _python_compile,
+    }
+    if command in builtins:
+        return builtins[command](base_dir, timeout)
+
+    try:
+        completed = subprocess.run(
+            command, cwd=str(base_dir), shell=True, text=True, encoding="utf-8",
+            errors="replace", capture_output=True, timeout=timeout,
+        )
+    except subprocess.TimeoutExpired:
+        log_path.parent.mkdir(parents=True, exist_ok=True)
+        log_path.write_text(f"$ {command}\nTimed out after {timeout}s.\n", encoding="utf-8")
+        return {"success": False, "command": command, "returncode": -1, "log": log_path.name}
+
+    output = (
+        f"$ {command}\ncwd={base_dir}\nreturncode={completed.returncode}\n\n"
+        f"[stdout]\n{completed.stdout}\n\n[stderr]\n{completed.stderr}\n"
+    )
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+    log_path.write_text(output, encoding="utf-8")
+    return {"success": completed.returncode == 0, "command": command, "returncode": completed.returncode, "log": log_path.name}
+
+
+def _file_smoke(base_dir: Path, _timeout: int) -> dict[str, Any]:
+    files = list_generated_files(base_dir)
+    success = bool(files)
+    return {"success": success, "command": "__builtin_file_smoke__", "returncode": 0 if success else 1, "details": f"{len(files)} files"}
+
+
+def _python_compile(base_dir: Path, timeout: int) -> dict[str, Any]:
+    py_files = [
+        str(p) for p in base_dir.rglob("*.py")
+        if not any(part in INTERNAL_DIRS for part in p.relative_to(base_dir).parts)
+    ]
+    if not py_files:
+        return {"success": True, "command": "__builtin_python_compile__", "returncode": 0, "details": "No Python files."}
+    completed = subprocess.run(
+        [sys.executable, "-m", "py_compile", *py_files],
+        cwd=str(base_dir), text=True, encoding="utf-8", errors="replace",
+        capture_output=True, timeout=timeout,
+    )
+    return {
+        "success": completed.returncode == 0,
+        "command": "__builtin_python_compile__",
+        "returncode": completed.returncode,
+        "details": (completed.stderr or "").strip()[:300],
+    }
+
+
+def _html_smoke(base_dir: Path, server: bool) -> dict[str, Any]:
+    marker = "__builtin_html_server_smoke__" if server else "__builtin_html_smoke__"
+    index = base_dir / "index.html"
+    if not index.exists():
+        return {"success": False, "command": marker, "returncode": 1, "details": "index.html missing"}
+    html = read_text(index)
+    missing: list[str] = []
+    for attr in re.findall(r"""(?:src|href)=["']([^"']+)["']""", html):
+        if attr.startswith(("http://", "https://", "data:", "#", "//", "mailto:")):
+            continue
+        target = base_dir / attr.split("?", 1)[0].lstrip("/")
+        if not target.exists():
+            missing.append(attr)
+    module = 'type="module"' in html or "type='module'" in html
+    if missing:
+        return {"success": False, "command": marker, "returncode": 1, "details": f"Missing assets: {missing[:5]}"}
+    if module and not server:
+        return {"success": False, "command": "__builtin_html_smoke__", "returncode": 1, "details": "Uses ES modules; needs a local server."}
+    return {"success": True, "command": marker, "returncode": 0, "details": "HTML assets resolved."}

autodevloop/util.py

@@ -0,0 +1,250 @@
+"""Filesystem, JSON, and text helpers shared across AutoDevLoop modules."""
+
+from __future__ import annotations
+
+import datetime as dt
+import filecmp
+import json
+import os
+import re
+import shutil
+import stat
+import threading
+from pathlib import Path
+from typing import Any
+
+APP_DIR = ".autodev"
+CONFIG_FILE = ".autodevloop.yml"
+STATE_FILE = "state.json"
+PROGRESS_FILE = "progress.json"
+STOP_FILE = "STOP"
+
+TEXT_SUFFIXES = {
+    ".css", ".html", ".js", ".json", ".jsx", ".md", ".mjs", ".py",
+    ".toml", ".ts", ".tsx", ".txt", ".yml", ".yaml", ".vue", ".svelte",
+    ".go", ".rs", ".java", ".kt", ".rb", ".php", ".c", ".cpp", ".h",
+    ".sh", ".sql", ".env", ".cfg", ".ini",
+}
+DOC_SUFFIXES = {".md", ".txt", ".rst"}
+INTERNAL_DIRS = {APP_DIR, ".git", "__pycache__", ".pytest_cache", "node_modules", ".venv", "dist", "build"}
+
+
+def now_text() -> str:
+    return dt.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+
+def ts() -> str:
+    return dt.datetime.now().strftime("%H:%M:%S")
+
+
+def slugify(value: str, fallback: str = "item") -> str:
+    cleaned = re.sub(r"[^A-Za-z0-9_-]+", "_", str(value)).strip("_")
+    return cleaned or fallback
+
+
+def write_text(path: Path, content: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(content, encoding="utf-8", newline="\n")
+
+
+def read_text(path: Path, default: str = "") -> str:
+    try:
+        return path.read_text(encoding="utf-8")
+    except (FileNotFoundError, UnicodeDecodeError, OSError):
+        return default
+
+
+def load_json(path: Path, default: Any) -> Any:
+    if not path.exists():
+        return default
+    try:
+        with path.open("r", encoding="utf-8") as fh:
+            return json.load(fh)
+    except (json.JSONDecodeError, OSError):
+        return default
+
+
+def json_safe(value: Any) -> Any:
+    if isinstance(value, Path):
+        return str(value)
+    if isinstance(value, dict):
+        return {str(k): json_safe(v) for k, v in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [json_safe(item) for item in value]
+    return value
+
+
+def save_json(path: Path, data: Any, stamp: bool = True) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if stamp and isinstance(data, dict):
+        data["updated_at"] = now_text()
+    # Unique temp name so concurrent writers never collide on the same file.
+    tmp = path.with_name(f"{path.name}.{os.getpid()}.{threading.get_ident()}.tmp")
+    with tmp.open("w", encoding="utf-8", newline="\n") as fh:
+        json.dump(json_safe(data), fh, ensure_ascii=False, indent=2)
+        fh.write("\n")
+    tmp.replace(path)
+
+
+def _chmod_retry(func, path, _exc) -> None:
+    """Clear the read-only bit (common on Windows .git objects) and retry."""
+    try:
+        os.chmod(path, stat.S_IWRITE)
+        func(path)
+    except OSError:
+        pass
+
+
+def rmtree_robust(path: Path) -> None:
+    if not path.exists():
+        return
+    try:  # Python 3.12+ uses onexc; older uses onerror.
+        shutil.rmtree(path, onexc=_chmod_retry)
+    except TypeError:
+        shutil.rmtree(path, onerror=_chmod_retry)
+
+
+def safe_rmtree(path: Path, root: Path) -> None:
+    resolved = path.resolve()
+    root_resolved = root.resolve()
+    try:
+        resolved.relative_to(root_resolved)
+    except ValueError as exc:
+        raise RuntimeError(f"refusing to delete outside project: {resolved}") from exc
+    rmtree_robust(path)
+
+
+def restore_working_dir(before_dir: Path, current_dir: Path) -> None:
+    """Restore current_dir's working files from a snapshot, keeping .git intact."""
+    if current_dir.exists():
+        for item in current_dir.iterdir():
+            if item.name in INTERNAL_DIRS:
+                continue
+            if item.is_dir():
+                rmtree_robust(item)
+            else:
+                try:
+                    item.unlink()
+                except OSError:
+                    pass
+    copy_tree_contents(before_dir, current_dir)
+
+
+def copy_tree_contents(source: Path, dest: Path) -> None:
+    dest.mkdir(parents=True, exist_ok=True)
+    if not source.exists():
+        return
+    for item in source.iterdir():
+        if item.name in INTERNAL_DIRS:
+            continue
+        target = dest / item.name
+        if item.is_dir():
+            shutil.copytree(item, target, dirs_exist_ok=True)
+        else:
+            target.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(item, target)
+
+
+def list_generated_files(base_dir: Path) -> list[str]:
+    if not base_dir.exists():
+        return []
+    files: list[str] = []
+    for path in sorted(base_dir.rglob("*")):
+        if path.is_dir():
+            continue
+        relative = path.relative_to(base_dir)
+        if any(part in INTERNAL_DIRS for part in relative.parts):
+            continue
+        files.append(relative.as_posix())
+    return files
+
+
+def collect_context(base_dir: Path, max_bytes: int = 70_000) -> str:
+    """Render a file tree plus readable file bodies, recency-prioritised."""
+    if not base_dir.exists():
+        return "(empty)"
+
+    tree: list[str] = ["File tree:"]
+    files: list[Path] = []
+    for path in sorted(base_dir.rglob("*")):
+        if path.is_dir():
+            continue
+        relative = path.relative_to(base_dir)
+        if any(part in INTERNAL_DIRS for part in relative.parts):
+            continue
+        files.append(path)
+        tree.append(f"- {relative.as_posix()}")
+
+    parts = list(tree)
+    parts.append("\nReadable files (most recently modified first):")
+    used = len("\n".join(parts).encode("utf-8"))
+    readable = [p for p in files if p.suffix.lower() in TEXT_SUFFIXES]
+    readable.sort(key=lambda p: p.stat().st_mtime if p.exists() else 0, reverse=True)
+    for path in readable:
+        relative = path.relative_to(base_dir).as_posix()
+        block = f'\n<existing_file path="{relative}">\n{read_text(path)}\n</existing_file>\n'
+        size = len(block.encode("utf-8"))
+        if used + size > max_bytes:
+            parts.append("\n(context truncated; older files omitted)")
+            break
+        parts.append(block)
+        used += size
+    return "\n".join(parts)
+
+
+def diff_file_lists(before_dir: Path, after_dir: Path) -> dict[str, list[str]]:
+    before = set(list_generated_files(before_dir))
+    after = set(list_generated_files(after_dir))
+    changed: list[str] = []
+    for relative in sorted(before & after):
+        left = before_dir / relative
+        right = after_dir / relative
+        try:
+            same = filecmp.cmp(left, right, shallow=False)
+        except OSError:
+            same = False
+        if not same:
+            changed.append(relative)
+    return {
+        "added": sorted(after - before),
+        "changed": changed,
+        "removed": sorted(before - after),
+    }
+
+
+def markdown_list(items: list[Any]) -> str:
+    values = [str(item).strip() for item in (items or []) if str(item).strip()]
+    return "\n".join(f"- {item}" for item in values) if values else "- None"
+
+
+def extract_json(raw: str, default: dict[str, Any]) -> dict[str, Any]:
+    """Best-effort JSON extraction from a model response (handles code fences)."""
+    text = raw.strip()
+    fence = re.search(r"```(?:json)?\s*(\{.*?\})\s*```", text, re.DOTALL)
+    if fence:
+        try:
+            value = json.loads(fence.group(1))
+            if isinstance(value, dict):
+                return value
+        except json.JSONDecodeError:
+            pass
+
+    try:
+        value = json.loads(text)
+        if isinstance(value, dict):
+            return value
+    except json.JSONDecodeError:
+        pass
+
+    decoder = json.JSONDecoder()
+    objects: list[tuple[int, dict[str, Any]]] = []
+    for idx, char in enumerate(text):
+        if char != "{":
+            continue
+        try:
+            value, end = decoder.raw_decode(text[idx:])
+        except json.JSONDecodeError:
+            continue
+        if isinstance(value, dict):
+            objects.append((len(json.dumps(value)), value))
+    return max(objects, key=lambda item: item[0])[1] if objects else default

autodevloop/vcs.py

@@ -0,0 +1,74 @@
+"""Lightweight git helpers for snapshotting each version inside current/.
+
+Git is optional: the versions/ folder copies remain the real backup. When git
+is available we additionally commit and tag every version, and place a special
+tag on the version where the user's goal is first fully met.
+"""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+
+GOAL_TAG = "goal-complete"
+
+
+def git_available() -> bool:
+    return shutil.which("git") is not None
+
+
+def _run(args: list[str], cwd: Path) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        ["git", *args],
+        cwd=str(cwd),
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+        capture_output=True,
+    )
+
+
+def ensure_repo(cwd: Path) -> bool:
+    """Initialise a git repo in cwd if needed. Returns True if usable."""
+    if not git_available():
+        return False
+    cwd.mkdir(parents=True, exist_ok=True)
+    if (cwd / ".git").exists():
+        return True
+    if _run(["init"], cwd).returncode != 0:
+        return False
+    # Ensure commits work even without a global identity configured.
+    if not _run(["config", "user.name"], cwd).stdout.strip():
+        _run(["config", "user.name", "AutoDevLoop"], cwd)
+    if not _run(["config", "user.email"], cwd).stdout.strip():
+        _run(["config", "user.email", "autodevloop@local"], cwd)
+    _run(["config", "commit.gpgsign", "false"], cwd)
+    gitignore = cwd / ".gitignore"
+    if not gitignore.exists():
+        gitignore.write_text("__pycache__/\nnode_modules/\n.venv/\ndist/\nbuild/\n", encoding="utf-8")
+    return True
+
+
+def commit_all(cwd: Path, message: str) -> str | None:
+    if not (cwd / ".git").exists():
+        return None
+    _run(["add", "-A"], cwd)
+    status = _run(["status", "--porcelain"], cwd)
+    if not status.stdout.strip():
+        # Nothing changed; still allow an (empty) commit so every version has one.
+        result = _run(["commit", "--allow-empty", "-m", message], cwd)
+    else:
+        result = _run(["commit", "-m", message], cwd)
+    if result.returncode != 0:
+        return None
+    rev = _run(["rev-parse", "--short", "HEAD"], cwd)
+    return rev.stdout.strip() or None
+
+
+def tag(cwd: Path, name: str, message: str = "") -> bool:
+    if not (cwd / ".git").exists():
+        return False
+    _run(["tag", "-d", name], cwd)  # replace if exists
+    result = _run(["tag", "-a", name, "-m", message or name], cwd)
+    return result.returncode == 0