luckyd-code 1.2.2__py3-none-any.whl

luckyd_code/verify.py

@@ -0,0 +1,360 @@
+"""Verification pipeline — multi-pass validation of code changes.
+
+Runs after every file write/edit to ensure correctness before the agent
+declares completion. The pipeline is:
+
+  1. Syntax check (fast, always runs)
+  2. Lint check (optional, configurable)
+  3. Test suite (if applicable)
+  4. Consistency check (project patterns)
+  5. Task completeness gate
+
+All verifications return a ``VerificationResult`` so the agent loop can
+decide whether to fix-and-retry or proceed.
+"""
+
+from __future__ import annotations
+
+import ast
+import os
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+
+# ------------------------------------------------------------------ #
+#  Data model
+# ------------------------------------------------------------------ #
+
+@dataclass
+class VerificationResult:
+    """Outcome of running the verification pipeline."""
+
+    passed: bool
+    stage: str                   # "syntax" | "lint" | "test" | "consistency" | "task"
+    message: str                 # human-readable result
+    fix_hint: Optional[str] = None  # what the model should do to fix it
+    raw_output: str = ""         # full tool output for context
+    duration_ms: float = 0.0
+
+    def to_agent_feedback(self) -> str:
+        """Format this result as a user message the agent can act on."""
+        if self.passed:
+            return f"[verify ✓] {self.stage} passed ({self.duration_ms:.0f}ms)"
+        lines = [
+            f"[verify ✗] {self.stage} FAILED:",
+            f"  {self.message}",
+        ]
+        if self.fix_hint:
+            lines.append(f"  Fix: {self.fix_hint}")
+        if self.raw_output:
+            lines.append(f"  ```\n{self.raw_output[:1500]}\n  ```")
+        return "\n".join(lines)
+
+
+# ------------------------------------------------------------------ #
+#  Verification stages
+# ------------------------------------------------------------------ #
+
+def verify_syntax(file_path: str) -> VerificationResult:
+    """Check Python syntax with py_compile."""
+    import time
+    t0 = time.time()
+    try:
+        import py_compile
+        py_compile.compile(file_path, doraise=True)
+        elapsed = (time.time() - t0) * 1000
+        return VerificationResult(
+            passed=True, stage="syntax", message="Syntax OK",
+            duration_ms=elapsed,
+        )
+    except py_compile.PyCompileError as e:
+        elapsed = (time.time() - t0) * 1000
+        return VerificationResult(
+            passed=False, stage="syntax",
+            message=f"Syntax error in {file_path}",
+            fix_hint=f"Fix the Python syntax error at {e}",
+            raw_output=str(e),
+            duration_ms=elapsed,
+        )
+
+
+def verify_lint(file_path: str, cwd: Optional[str] = None, project_root: Optional[str] = None) -> Optional[VerificationResult]:
+    """Run ruff/flake8 on the changed file. Returns None if no linter is available.
+
+    Linters are invoked from *project_root* (when provided) so they pick up
+    the project-level ``pyproject.toml`` / ``.flake8`` config instead of
+    falling back to built-in defaults.
+    """
+    import time
+    t0 = time.time()
+
+    # Prefer project_root so linters find pyproject.toml / .flake8 config.
+    # Fall back to the explicit cwd arg, then the file's parent directory.
+    run_cwd = project_root or cwd or str(Path(file_path).parent)
+
+    linters = [
+        ("ruff", ["ruff", "check", file_path, "--output-format=concise"]),
+        ("flake8", ["flake8", file_path, "--max-line-length=120"]),
+    ]
+
+    for name, cmd in linters:
+        try:
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=30,
+                cwd=run_cwd,
+            )
+            elapsed = (time.time() - t0) * 1000
+            combined = (result.stdout + result.stderr).strip()
+            if result.returncode == 0 and not combined:
+                return VerificationResult(
+                    passed=True, stage="lint",
+                    message=f"{name}: no issues",
+                    duration_ms=elapsed,
+                )
+            else:
+                return VerificationResult(
+                    passed=False, stage="lint",
+                    message=f"{name} found issues in {file_path}",
+                    fix_hint="Fix the lint issues listed above",
+                    raw_output=combined[:2000],
+                    duration_ms=elapsed,
+                )
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            continue
+
+    return None  # no linter available — not a failure
+
+
+def verify_consistency(file_path: str, project_root: str) -> Optional[VerificationResult]:
+    """Check that the file follows project conventions.
+
+    Currently checks:
+    - Imports follow project structure (no circular imports)
+    - File uses same encoding/style as the project
+    - Type hints are present (if project uses them)
+
+    Returns None if no checks apply (not a failure).
+    """
+    import time
+    t0 = time.time()
+
+    p = Path(file_path)
+    if not p.exists() or p.suffix != ".py":
+        return None
+
+    issues: list[str] = []
+
+    try:
+        tree = ast.parse(p.read_text(encoding="utf-8"))
+    except SyntaxError:
+        return None  # syntax check will catch this
+
+    # Check for __init__.py imports that might actually cause circular imports
+    # Only flag when a submodule import could form a true cycle:
+    # e.g. __init__.py does "from .foo import Bar" and foo.py does "from . import Bar"
+    # Simple imports in __init__.py are standard Python practice — not an issue.
+    if p.name == "__init__.py":
+        package_dir = p.parent
+        module_name = p.parent.name
+        for node in ast.walk(tree):
+            if isinstance(node, ast.ImportFrom) and node.module is not None:
+                # Flag only if the imported submodule also imports from this package
+                target = node.module
+                if target.startswith("."):
+                    # Should not happen (dots tracked by level), but handle gracefully
+                    target = target.lstrip(".")
+                # Resolve the actual module name.
+                # level=0 → absolute import, level=1 → same package, level=2 → parent, etc.
+                if node.level == 0:
+                    # Absolute import — target is already a fully-qualified module name
+                    target_module = target
+                else:
+                    parts = module_name.split(".")
+                    base_parts = parts[:len(parts) - (node.level - 1)]
+                    target_module = ".".join(base_parts + [target]) if base_parts else target
+                # Check if the target module might import back from this package
+                target_file = package_dir / (target_module.replace(".", os.sep) + ".py")
+                if target_file.exists():
+                    try:
+                        target_tree = ast.parse(target_file.read_text(encoding="utf-8"))
+                        for target_node in ast.walk(target_tree):
+                            if isinstance(target_node, ast.ImportFrom):
+                                if target_node.module and module_name in target_node.module:
+                                    issues.append(
+                                        f"Circular import detected: {p.name} imports from "
+                                        f"'{target_module}' which also imports from '{module_name}'. "
+                                        f"Consider lazy imports."
+                                    )
+                                    break
+                    except (SyntaxError, OSError):
+                        pass
+                # do NOT break here — continue scanning remaining imports in __init__.py
+
+    # Check for bare except clauses
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ExceptHandler):
+            if node.type is None:
+                issues.append("Bare except: clause — replace with 'except Exception'")
+            elif isinstance(node.type, ast.Tuple) or (
+                isinstance(node.type, ast.Name) and node.type.id == "Exception"
+            ):
+                pass  # ok
+            elif isinstance(node.type, ast.Name) and node.type.id == "BaseException":
+                issues.append("Catching BaseException — use Exception instead")
+
+    # Check for mutable default arguments
+    for node in ast.walk(tree):
+        if isinstance(node, ast.FunctionDef):
+            for default in node.args.defaults + node.args.kw_defaults:
+                if isinstance(default, (ast.List, ast.Dict, ast.Set)):
+                    issues.append(
+                        f"Mutable default argument in {node.name}() — "
+                        f"use None and set default in function body"
+                    )
+
+    elapsed = (time.time() - t0) * 1000
+
+    if issues:
+        return VerificationResult(
+            passed=False, stage="consistency",
+            message=f"Found {len(issues)} consistency issue(s)",
+            fix_hint="\n".join(f"  • {i}" for i in issues),
+            raw_output="\n".join(issues),
+            duration_ms=elapsed,
+        )
+    return VerificationResult(
+        passed=True, stage="consistency",
+        message="No consistency issues found",
+        duration_ms=elapsed,
+    )
+
+
+# ------------------------------------------------------------------ #
+#  Full pipeline
+# ------------------------------------------------------------------ #
+
+
+def run_verify_pipeline(
+    file_path: str,
+    project_root: str,
+    run_lint: bool = True,
+    run_consistency: bool = True,
+    run_tests: bool = False,
+    test_runner_cmd: Optional[str] = None,
+) -> list[VerificationResult]:
+    """Run all applicable verification stages on a file.
+
+    Args:
+        file_path: Absolute path to the file to verify.
+        project_root: Project root for context.
+        run_lint: If True, attempt lint check.
+        run_consistency: If True, run AST-based consistency checks.
+        run_tests: If True, run the project test suite.
+        test_runner_cmd: Shell command to run tests.
+
+    Returns:
+        List of VerificationResult, one per stage that ran.
+    """
+    results: list[VerificationResult] = []
+    import time
+
+    # Stage 1: Syntax (always, mandatory)
+    results.append(verify_syntax(file_path))
+
+    # If syntax failed, skip remaining stages (file is broken)
+    if not results[-1].passed:
+        return results
+
+    # Stage 2: Lint (optional, best-effort)
+    if run_lint:
+        lint_result = verify_lint(file_path, project_root=project_root)
+        if lint_result is not None:
+            results.append(lint_result)
+
+    # Stage 3: Consistency (optional)
+    if run_consistency:
+        consistency_result = verify_consistency(file_path, project_root)
+        if consistency_result is not None:
+            results.append(consistency_result)
+
+    # Stage 4: Tests (optional, run if requested)
+    if run_tests and test_runner_cmd:
+        # Allowlist check: only permit simple pytest / unittest invocations
+        # to prevent shell injection if the command comes from settings or LLM.
+        import shlex
+        _allowed_runners = ("pytest", "python -m pytest", "python -m unittest", "tox", "uv run pytest")
+        _cmd_stripped = test_runner_cmd.strip()
+        if not any(_cmd_stripped.startswith(r) for r in _allowed_runners):
+            results.append(VerificationResult(
+                passed=False, stage="test",
+                message=f"Blocked: test_runner_cmd '{_cmd_stripped[:80]}' is not an allowed test runner",
+                fix_hint="Use pytest, python -m pytest, python -m unittest, tox, or uv run pytest",
+            ))
+            return results
+        t0 = time.time()
+        try:
+            proc = subprocess.run(
+                test_runner_cmd,
+                shell=True,
+                capture_output=True,
+                text=True,
+                timeout=120,
+                cwd=project_root,
+            )
+            elapsed = (time.time() - t0) * 1000
+            combined = (proc.stdout + proc.stderr).strip()
+            if proc.returncode == 0:
+                results.append(VerificationResult(
+                    passed=True, stage="test",
+                    message="All tests passed",
+                    raw_output=combined[:1000],
+                    duration_ms=elapsed,
+                ))
+            else:
+                results.append(VerificationResult(
+                    passed=False, stage="test",
+                    message=f"Tests failed (exit code {proc.returncode})",
+                    fix_hint="Fix the failing tests before proceeding",
+                    raw_output=combined[:3000],
+                    duration_ms=elapsed,
+                ))
+        except subprocess.TimeoutExpired:
+            results.append(VerificationResult(
+                passed=False, stage="test",
+                message="Test run timed out (120s)",
+                fix_hint="Check for infinite loops or hanging tests",
+                duration_ms=120000,
+            ))
+        except Exception as e:
+            results.append(VerificationResult(
+                passed=False, stage="test",
+                message=f"Could not run tests: {e}",
+                duration_ms=(time.time() - t0) * 1000,
+            ))
+
+    return results
+
+
+def pipeline_all_passed(results: list[VerificationResult]) -> bool:
+    """True if all mandatory stages passed."""
+    for r in results:
+        if not r.passed and r.stage in ("syntax", "test", "consistency"):
+            return False
+    return True
+
+
+def pipeline_feedback(results: list[VerificationResult]) -> str:
+    """Build a single feedback message from all verification results."""
+    if not results:
+        return ""
+    passed = sum(1 for r in results if r.passed)
+    total = len(results)
+    lines = [f"## Verification: {passed}/{total} passed\n"]
+    for r in results:
+        lines.append(r.to_agent_feedback())
+    return "\n".join(lines)

luckyd_code/web_app.py

@@ -0,0 +1,176 @@
+"""Web UI server for LuckyD Code."""
+
+import time
+from collections import defaultdict
+from typing import Any, Optional
+
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
+import uvicorn
+
+# Module-level imports so test patches to luckyd_code.web_app.X still resolve
+from .api import stream_chat
+from .config import Config
+from .context import ConversationContext
+from .tools import get_default_registry
+from . import memory as memory_module
+from .mcp.client import MCPManager
+from .log import get_logger
+from .web_routes import WebAppState
+
+logger = get_logger()
+
+
+def create_app(config: Optional[Config] = None) -> FastAPI:
+    if config is None:
+        config = Config()
+        try:
+            config.validate()
+        except ValueError as e:
+            logger.warning(f"Config validation: {e}")
+
+    registry = get_default_registry()
+
+    # Wire up agent tools so SubAgent and AgentHandoff work from the web UI
+    from .tools.agent_tools import set_repl as _set_repl
+
+    class _WebRepl:
+        """Minimal repl-like object the agent tools need."""
+        config: Config
+        registry: Any
+
+    _web_repl = _WebRepl()
+    _web_repl.config = config
+    _web_repl.registry = registry
+    _set_repl(_web_repl)
+    mcp = MCPManager()
+    settings = {}
+    try:
+        from . import settings as cfg
+        settings = cfg.load_settings()
+        mcp.load_from_config(settings)
+    except Exception:
+        logger.warning("Failed to load MCP servers", exc_info=True)
+    context = ConversationContext(config.system_prompt, max_messages=100)
+
+    # Load project memory (MEMORY.md) merged with session memories for a single memory block
+    from .memory import MemoryManager
+    web_memory_mgr = MemoryManager()
+    md = memory_module.load_claude_md()
+    session_memories = web_memory_mgr.get_all_memories_formatted()
+    if md and session_memories:
+        merged = md + "\n\n" + session_memories
+    elif session_memories:
+        merged = session_memories
+    else:
+        merged = md or ""
+
+    if merged:
+        context.messages.insert(1, {
+            "role": "user",
+            "content": f"<claude-md>{merged}</claude-md>",
+        })
+
+    # Smart project indexing
+    from .indexer import index_project
+    project_context = index_project()
+    if project_context:
+        idx = 2 if md else 1
+        has_context = any(
+            isinstance(m.get("content"), str) and m["content"].startswith("<project-context>")
+            for m in context.messages
+        )
+        if not has_context:
+            context.messages.insert(idx, {
+                "role": "user",
+                "content": f"<project-context>\n{project_context}\n</project-context>",
+            })
+            logger.info(f"Project indexed ({project_context.count(chr(10)) + 1} items)")
+
+    app = FastAPI(title="LuckyD Code")
+
+    # --- Auth middleware ---
+    web_token = settings.get("web_token", "")
+    if web_token:
+        @app.middleware("http")
+        async def auth_middleware(request: Request, call_next):
+            if request.url.path in ("/", "/manifest.json", "/sw.js",
+                                    "/icon-192.png", "/icon-512.png"):
+                return await call_next(request)
+            auth = request.headers.get("authorization", "")
+            if auth != f"Bearer {web_token}":
+                return JSONResponse({"error": "Unauthorized"}, status_code=401)
+            return await call_next(request)
+
+    # --- Rate limiting middleware (token bucket, per-IP) ---
+    rate_limit_buckets: dict = defaultdict(lambda: {"tokens": 60, "last": time.time()})
+    RATE_LIMIT_RATE = 60
+    RATE_LIMIT_WINDOW = 60.0
+
+    @app.middleware("http")
+    async def rate_limit_middleware(request: Request, call_next):
+        if request.url.path in ("/", "/manifest.json", "/sw.js",
+                                "/icon-192.png", "/icon-512.png"):
+            return await call_next(request)
+        ip = request.client.host if request.client else "unknown"
+        bucket = rate_limit_buckets[ip]
+        now = time.time()
+        elapsed = now - bucket["last"]
+        bucket["last"] = now
+        bucket["tokens"] = min(bucket["tokens"] + elapsed * (RATE_LIMIT_RATE / RATE_LIMIT_WINDOW), RATE_LIMIT_RATE)
+        if bucket["tokens"] < 1:
+            return JSONResponse({"error": "Rate limit exceeded"}, status_code=429)
+        bucket["tokens"] -= 1
+        return await call_next(request)
+
+    # --- Attach shared state ---
+    app.state.web_state = WebAppState(
+        config=config,
+        context=context,
+        registry=registry,
+        mcp=mcp,
+        web_memory_mgr=web_memory_mgr,
+        settings=settings,
+        rate_limit_buckets=rate_limit_buckets,
+        memory_module=memory_module,
+    )
+
+    # --- Register routers ---
+    from .web_routes import static, files, brain, sessions, settings as settings_routes
+    from .web_routes import memories, project, review, background, cost, update, misc, ws
+
+    app.include_router(static.router)
+    app.include_router(files.router)
+    app.include_router(brain.router)
+    app.include_router(sessions.router)
+    app.include_router(settings_routes.router)
+    app.include_router(memories.router)
+    app.include_router(project.router)
+    app.include_router(review.router)
+    app.include_router(background.router)
+    app.include_router(cost.router)
+    app.include_router(update.router)
+    app.include_router(misc.router)
+    app.include_router(ws.router)
+
+    return app
+
+
+_app_instance = None
+
+
+def get_app() -> FastAPI:
+    """Lazy-init the app instance. create_app() runs only on first call."""
+    global _app_instance
+    if _app_instance is None:
+        _app_instance = create_app()
+    return _app_instance
+
+
+def run_web(host: str = "127.0.0.1", port: int = 8000):
+    """Run the web UI server.
+
+    Defaults to localhost only (127.0.0.1) for security.
+    Pass host='0.0.0.0' explicitly to expose on the local network.
+    """
+    uvicorn.run(get_app(), host=host, port=port)

luckyd_code/web_routes/__init__.py

@@ -0,0 +1,23 @@
+"""Shared state for web route handlers, attached to app.state.web_state."""
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, Optional
+
+
+@dataclass
+class WebAppState:
+    """Mutable shared state injected into every request via app.state.web_state."""
+    config: Any = None
+    context: Any = None
+    registry: Any = None
+    mcp: Any = None
+    web_memory_mgr: Any = None
+    settings: Dict[str, Any] = field(default_factory=dict)
+    rate_limit_buckets: Dict[str, Dict[str, float]] = field(default_factory=dict)
+    memory_module: Any = None
+    brain_module: Any = None
+
+    # Imported lazily by routes
+    knowledge_graph: Any = None
+    retriever: Any = None
+    context_assembler: Any = None

luckyd_code/web_routes/background.py

@@ -0,0 +1,73 @@
+"""Background agent task routes."""
+
+from fastapi import APIRouter, Request
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+
+from ..log import get_logger
+
+logger = get_logger()
+router = APIRouter()
+
+
+class BackgroundStart(BaseModel):
+    task: str
+
+
+@router.get("/api/background")
+async def background_list(request: Request):
+    try:
+        from ..background import BackgroundAgent
+        state = request.app.state.web_state
+        bg = BackgroundAgent(state.config)
+        bg.load_history()
+        statuses = bg.get_status()
+        return {"tasks": statuses}
+    except Exception as e:
+        logger.warning(f"background_list error: {e}")
+        return JSONResponse({"error": str(e)}, status_code=500)
+
+
+@router.post("/api/background/start")
+async def background_start(request: Request, data: BackgroundStart):
+    try:
+        from ..background import BackgroundAgent
+        state = request.app.state.web_state
+        task = data.task or ""
+        if not task:
+            return JSONResponse({"error": "task description required"}, status_code=400)
+        bg = BackgroundAgent(state.config)
+        task_id = bg.start_task(task)
+        return {"task_id": task_id, "status": "started"}
+    except Exception as e:
+        return JSONResponse({"error": str(e)}, status_code=500)
+
+
+@router.get("/api/background/status/{task_id}")
+async def background_status(request: Request, task_id: str):
+    try:
+        from ..background import BackgroundAgent
+        state = request.app.state.web_state
+        bg = BackgroundAgent(state.config)
+        bg.load_history()
+        statuses = bg.get_status(task_id)
+        if statuses:
+            return {"task": statuses[0]}
+        return JSONResponse({"error": "Task not found"}, status_code=404)
+    except Exception as e:
+        return JSONResponse({"error": str(e)}, status_code=500)
+
+
+@router.get("/api/background/result/{task_id}")
+async def background_result(request: Request, task_id: str):
+    try:
+        from ..background import BackgroundAgent
+        state = request.app.state.web_state
+        bg = BackgroundAgent(state.config)
+        bg.load_history()
+        result = bg.get_result(task_id)
+        if result:
+            return {"result": result}
+        return JSONResponse({"error": "Result not available"}, status_code=404)
+    except Exception as e:
+        return JSONResponse({"error": str(e)}, status_code=500)