luckyd-code 1.2.2__py3-none-any.whl

luckyd_code/web_routes/brain.py

@@ -0,0 +1,109 @@
+"""Knowledge graph / brain routes."""
+
+from fastapi import APIRouter, Request
+from fastapi.responses import JSONResponse
+
+router = APIRouter()
+
+
+@router.get("/api/brain")
+async def brain_status(request: Request):
+    from ..brain import KnowledgeGraph, Retriever, VectorIndexer
+    brain = KnowledgeGraph()
+    brain.load()
+
+    rag_available = False
+    try:
+        idx = VectorIndexer()
+        rag_available = idx.load()
+    except Exception:
+        pass
+
+    if not brain.nodes and not rag_available:
+        return {"status": "empty", "message": "Knowledge graph is empty. Use /api/brain/rebuild to index your codebase."}
+
+    result = {
+        "symbols": brain.stats.get("node_count", 0),
+        "relations": brain.stats.get("edge_count", 0),
+        "files_parsed": brain.stats.get("files_parsed", 0),
+    }
+    if brain.stats.get("last_built"):
+        import time
+        result["last_built"] = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(brain.stats["last_built"]))
+
+    if rag_available:
+        try:
+            r = Retriever()
+            info = r.stats()
+            vec = info.get("vector", {})
+            result["rag_chunks"] = vec.get("chunks", 0)
+            result["rag_files"] = vec.get("files", 0)
+        except Exception:
+            pass
+
+    return result
+
+
+@router.post("/api/brain/rebuild")
+async def brain_rebuild(request: Request):
+    from ..brain import rebuild_project
+    import os
+    result = rebuild_project(os.getcwd())
+
+    state = request.app.state.web_state
+    if state.knowledge_graph:
+        state.knowledge_graph.load()
+
+    return {
+        "status": "ok",
+        "chunks": result.get("chunks", 0),
+        "files": result.get("files", 0),
+        "symbols": result.get("node_count", 0),
+        "files_parsed": result.get("files_parsed", 0),
+    }
+
+
+@router.get("/api/brain/search")
+async def brain_search(request: Request, q: str = "", max_results: int = 5):
+    if not q:
+        return {"results": []}
+    try:
+        from ..brain import Retriever
+        r = Retriever()
+        results = r.search(q, k=max_results)
+        formatted = []
+        for res in results:
+            formatted.append({
+                "content": res.get("content", "")[:500],
+                "file": res.get("file", ""),
+                "score": res.get("score", 0),
+            })
+        return {"results": formatted}
+    except Exception as e:
+        return JSONResponse({"error": str(e)}, status_code=500)
+
+
+@router.get("/api/brain/stats")
+async def brain_stats(request: Request):
+    try:
+        from ..brain import Retriever
+        r = Retriever()
+        info = r.stats()
+        return info
+    except Exception as e:
+        return JSONResponse({"error": str(e)}, status_code=500)
+
+
+@router.get("/api/brain/dependents")
+async def brain_dependents(request: Request, symbol: str = ""):
+    """Find all nodes that depend on a symbol in the knowledge graph."""
+    if not symbol:
+        return JSONResponse({"error": "symbol parameter required"}, status_code=400)
+    try:
+        from ..brain import KnowledgeGraph
+        kg = KnowledgeGraph()
+        kg.load()
+        deps = kg.find_dependents(symbol)
+        return {"symbol": symbol, "dependents": deps, "count": len(deps)}
+    except Exception as e:
+        return JSONResponse({"error": str(e)}, status_code=500)

luckyd_code/web_routes/cost.py

@@ -0,0 +1,12 @@
+"""Cost tracking route."""
+
+from fastapi import APIRouter, Request
+
+router = APIRouter()
+
+
+@router.get("/api/cost")
+async def get_cost(request: Request):
+    from ..cost_tracker import CostTracker
+    tracker = CostTracker()
+    return tracker.get_stats()

luckyd_code/web_routes/files.py

@@ -0,0 +1,133 @@
+"""File browsing, reading, writing, and editing routes."""
+
+from pathlib import Path
+
+from fastapi import APIRouter, Request
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+
+from ..tools import path_validate
+
+router = APIRouter()
+
+MAX_MESSAGE_LENGTH = 10000
+MAX_READ_BYTES = 1_000_000   # 1 MB
+MAX_WRITE_BYTES = 10_485_760  # 10 MB — matches CLI WriteTool
+
+
+def _safe_resolve(path: str):
+    """Wrap safe_resolve so callers get None instead of a raw ValueError."""
+    try:
+        return path_validate.safe_resolve(path)
+    except ValueError:
+        return None
+
+
+class WriteData(BaseModel):
+    path: str = ""
+    content: str = ""
+
+
+class EditData(BaseModel):
+    path: str = ""
+    old_string: str = ""
+    new_string: str = ""
+
+
+@router.get("/api/tools")
+async def list_tools(request: Request):
+    """List available tool names."""
+    state = request.app.state.web_state
+    tools = state.registry.list_tools()
+    tool_objects = [{"name": t["function"]["name"]} for t in tools]
+    return {"tools": tool_objects, "count": len(tools)}
+
+
+@router.get("/api/files")
+async def list_files(request: Request, dir: str = "."):
+    """List directory contents."""
+    safe = _safe_resolve(dir)
+    if safe is None:
+        return JSONResponse({"error": "Access denied: path traversal detected"}, status_code=403)
+    path = Path(safe)
+    if not path.exists():
+        return JSONResponse({"error": f"Directory not found: {dir}"}, status_code=404)
+    if not path.is_dir():
+        return JSONResponse({"error": f"Not a directory: {dir}"}, status_code=400)
+
+    try:
+        items = []
+        for child in sorted(path.iterdir()):
+            try:
+                items.append({
+                    "name": child.name,
+                    "is_dir": child.is_dir(),
+                    "size": child.stat().st_size if child.is_file() else 0,
+                })
+            except OSError:
+                continue
+        parent = str(path.parent) if path.parent != path else str(path)
+        return {"files": items, "current": str(path), "parent": parent}
+    except PermissionError:
+        return JSONResponse({"error": "Permission denied"}, status_code=403)
+
+
+@router.get("/api/read-file")
+async def read_file(request: Request, path: str = ""):
+    if not path:
+        return JSONResponse({"error": "path parameter required"}, status_code=400)
+    safe = _safe_resolve(path)
+    if safe is None:
+        return JSONResponse({"error": "Access denied: path traversal detected"}, status_code=403)
+    file_path = Path(safe)
+    if not file_path.exists():
+        return JSONResponse({"error": f"File not found: {path}"}, status_code=404)
+    if not file_path.is_file():
+        return JSONResponse({"error": f"Not a file: {path}"}, status_code=400)
+    try:
+        # Check size via stat before reading into memory
+        if file_path.stat().st_size > MAX_READ_BYTES:
+            return JSONResponse({"error": "File too large (max 1 MB)"}, status_code=413)
+        content = file_path.read_text(encoding="utf-8")
+        return {"content": content, "path": str(file_path), "size": len(content)}
+    except Exception as e:
+        return JSONResponse({"error": f"Failed to read file: {e}"}, status_code=500)
+
+
+@router.post("/api/write-file")
+async def write_file(request: Request, data: WriteData):
+    if not data.path:
+        return JSONResponse({"error": "path required"}, status_code=400)
+    if len(data.content) > MAX_WRITE_BYTES:
+        return JSONResponse({"error": "Content too large (max 10 MB)"}, status_code=413)
+    safe = _safe_resolve(data.path)
+    if safe is None:
+        return JSONResponse({"error": "Access denied: path traversal detected"}, status_code=403)
+    file_path = Path(safe)
+    try:
+        file_path.parent.mkdir(parents=True, exist_ok=True)
+        file_path.write_text(data.content, encoding="utf-8")
+        return {"status": "written", "path": str(file_path), "size": len(data.content)}
+    except Exception as e:
+        return JSONResponse({"error": f"Failed to write file: {e}"}, status_code=500)
+
+
+@router.post("/api/edit-file")
+async def edit_file(request: Request, data: EditData):
+    if not data.path or not data.old_string:
+        return JSONResponse({"error": "path and old_string required"}, status_code=400)
+    safe = _safe_resolve(data.path)
+    if safe is None:
+        return JSONResponse({"error": "Access denied: path traversal detected"}, status_code=403)
+    file_path = Path(safe)
+    if not file_path.exists():
+        return JSONResponse({"error": f"File not found: {data.path}"}, status_code=404)
+    try:
+        content = file_path.read_text(encoding="utf-8")
+        if data.old_string not in content:
+            return JSONResponse({"error": "old_string not found in file", "content": content}, status_code=400)
+        new_content = content.replace(data.old_string, data.new_string, 1)
+        file_path.write_text(new_content, encoding="utf-8")
+        return {"status": "edited", "path": str(file_path), "replacements": 1}
+    except Exception as e:
+        return JSONResponse({"error": f"Failed to edit file: {e}"}, status_code=500)

luckyd_code/web_routes/memories.py

@@ -0,0 +1,94 @@
+"""Memory (MEMORY.md and named memories) routes."""
+
+from fastapi import APIRouter, Request
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+
+from ..web_app import memory_module
+
+router = APIRouter()
+
+
+# --- Project Memory (MEMORY.md) ---
+
+@router.get("/api/memory")
+async def get_memory(request: Request):
+    state = request.app.state.web_state
+    md = memory_module.load_claude_md()
+    return {"claude_md": md, "message_count": state.context.count_messages()}
+
+
+class MemorySave(BaseModel):
+    content: str = ""
+
+
+@router.post("/api/memory/save")
+async def save_memory(request: Request, data: MemorySave):
+    memory_module.save_claude_md(data.content)
+    # Update context so the change is reflected immediately.
+    # The <claude-md> block may also contain session memories — preserve them.
+    state = request.app.state.web_state
+    session_suffix = ""
+    for m in state.context.messages:
+        if isinstance(m.get("content"), str) and m["content"].startswith("<claude-md>"):
+            inner = m["content"][len("<claude-md>"):-len("</claude-md>")]
+            if "<memories>" in inner:
+                session_suffix = "\n\n" + inner[inner.index("<memories>"):]
+            break
+    merged = data.content + session_suffix
+    for i, m in enumerate(state.context.messages):
+        if isinstance(m.get("content"), str) and m["content"].startswith("<claude-md>"):
+            state.context.messages[i]["content"] = f"<claude-md>{merged}</claude-md>"
+            break
+    else:
+        state.context.messages.insert(1, {
+            "role": "user",
+            "content": f"<claude-md>{merged}</claude-md>",
+        })
+    return {"status": "saved"}
+
+
+# --- Named memories ---
+
+@router.get("/api/memories")
+async def list_memories(request: Request, q: str = ""):
+    state = request.app.state.web_state
+    mgr = state.web_memory_mgr
+    if q:
+        results = mgr.search_memories(q)
+        return {"memories": results}
+    all_memories = mgr.list_memories()
+    return {"memories": all_memories}
+
+
+class NamedMemorySave(BaseModel):
+    name: str
+    content: str
+
+
+@router.post("/api/memories/save")
+async def save_memory_web(request: Request, data: NamedMemorySave):
+    state = request.app.state.web_state
+    mgr = state.web_memory_mgr
+    mgr.save_memory(data.name, data.content)
+    return {"status": "ok", "name": data.name}
+
+
+@router.delete("/api/memories/{name}")
+async def delete_memory_web(request: Request, name: str):
+    state = request.app.state.web_state
+    mgr = state.web_memory_mgr
+    ok = mgr.delete_memory(name)
+    if ok:
+        return {"status": "ok", "name": name}
+    return JSONResponse({"error": "Memory not found"}, status_code=404)
+
+
+@router.get("/api/memories/{name}")
+async def get_memory_web(request: Request, name: str):
+    state = request.app.state.web_state
+    mgr = state.web_memory_mgr
+    content = mgr.load_memory(name)
+    if content:
+        return {"name": name, "content": content}
+    return JSONResponse({"error": "Memory not found"}, status_code=404)

luckyd_code/web_routes/misc.py

@@ -0,0 +1,67 @@
+"""Miscellaneous routes: clear, undo, compact, context info."""
+
+from fastapi import APIRouter, Request
+from fastapi.responses import JSONResponse
+
+router = APIRouter()
+
+
+@router.post("/api/clear")
+async def clear_context(request: Request):
+    try:
+        state = request.app.state.web_state
+        context = state.context
+        memory_module = state.memory_module
+        context.reset()
+        # Re-inject merged memory block
+        from ..memory import MemoryManager
+        mgr = MemoryManager()
+        md = memory_module.load_claude_md()
+        session_memories = 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>",
+            })
+        return {"status": "cleared"}
+    except Exception as e:
+        return JSONResponse({"error": str(e)}, status_code=500)
+
+
+@router.post("/api/undo")
+async def undo():
+    try:
+        from ..undo import undo_last
+        result = undo_last()
+        return {"status": result}
+    except Exception as e:
+        return JSONResponse({"error": str(e)}, status_code=500)
+
+
+@router.post("/api/compact")
+async def compact(request: Request):
+    try:
+        state = request.app.state.web_state
+        result = state.context.compact(state.config, state.config.model)
+        return {"status": result}
+    except Exception as e:
+        return JSONResponse({"error": str(e)}, status_code=500)
+
+
+@router.get("/api/context")
+async def context_info(request: Request):
+    try:
+        context = request.app.state.web_state.context
+        return {
+            "message_count": context.count_messages(),
+            "max_messages": context.max_messages,
+            "estimated_tokens": context.estimate_tokens(),
+        }
+    except Exception as e:
+        return JSONResponse({"error": str(e)}, status_code=500)

luckyd_code/web_routes/project.py

@@ -0,0 +1,48 @@
+"""Project initialization, indexing, tasks, and plans routes."""
+
+from fastapi import APIRouter, Request
+
+from .. import tasks, planner, init as project_init
+
+router = APIRouter()
+
+
+@router.post("/api/init")
+async def init_project():
+    result = project_init.init_project()
+    return {"status": "ok", "message": result}
+
+
+@router.post("/api/index")
+async def reindex_project(request: Request):
+    from ..indexer import index_project
+    project_context = index_project()
+    state = request.app.state.web_state
+    if project_context and state.context:
+        new_content = f"<project-context>\n{project_context}\n</project-context>"
+        replaced = False
+        for i, m in enumerate(state.context.messages):
+            content = str(m.get("content", ""))
+            if content.startswith("<project-context>") and content.endswith("</project-context>"):
+                state.context.messages[i]["content"] = new_content
+                replaced = True
+                break
+        if not replaced:
+            state.context.messages.insert(1, {
+                "role": "user",
+                "content": new_content,
+            })
+        return {"status": "ok", "items": project_context.count("\n") + 1}
+    return {"status": "ok", "items": 0}
+
+
+@router.get("/api/tasks")
+async def list_tasks(status: str = ""):
+    result = tasks.list_tasks(status or None)
+    return {"tasks": result}
+
+
+@router.get("/api/plans")
+async def list_plans():
+    plans = planner.list_plans()
+    return {"plans": plans}

luckyd_code/web_routes/review.py

@@ -0,0 +1,20 @@
+"""Code review and security review routes."""
+
+from fastapi import APIRouter
+
+from ..skills import review as review_skill
+from ..skills import security as security_skill
+
+router = APIRouter()
+
+
+@router.get("/api/review")
+async def review_code():
+    diff = review_skill.review_changes()
+    return {"diff": diff}
+
+
+@router.get("/api/security-review")
+async def security_review():
+    analysis = security_skill.security_review()
+    return {"analysis": analysis}

luckyd_code/web_routes/sessions.py

@@ -0,0 +1,44 @@
+"""Session management routes."""
+
+from fastapi import APIRouter, Request
+from pydantic import BaseModel
+
+router = APIRouter()
+
+
+class SessionSave(BaseModel):
+    name: str
+
+
+class SessionLoad(BaseModel):
+    name: str
+
+
+@router.get("/api/sessions")
+async def sessions_list():
+    from ..sessions import list_sessions
+    result = list_sessions()
+    return {"sessions": result}
+
+
+@router.post("/api/sessions/save")
+async def sessions_save(request: Request, data: SessionSave):
+    from ..sessions import save_session
+    state = request.app.state.web_state
+    result = save_session(data.name, state.context)
+    return {"status": "ok", "message": result}
+
+
+@router.post("/api/sessions/load")
+async def sessions_load(request: Request, data: SessionLoad):
+    from ..sessions import load_session
+    state = request.app.state.web_state
+    result = load_session(data.name, state.context)
+    return {"status": "ok", "message": result}
+
+
+@router.delete("/api/sessions/{name}")
+async def sessions_delete(name: str):
+    from ..sessions import delete_session
+    result = delete_session(name)
+    return {"status": "ok", "message": result}

luckyd_code/web_routes/settings.py

@@ -0,0 +1,43 @@
+"""Settings and model configuration routes."""
+
+from fastapi import APIRouter, Request
+from pydantic import BaseModel
+
+from .. import settings as cfg
+
+router = APIRouter()
+
+
+@router.get("/api/settings")
+async def get_settings(request: Request):
+    return cfg.load_settings()
+
+
+class SettingUpdate(BaseModel):
+    key: str
+    value: str
+
+
+@router.post("/api/settings")
+async def set_settings(data: SettingUpdate):
+    cfg.save_setting(data.key, data.value)
+    return {"status": "ok", "key": data.key, "value": data.value}
+
+
+@router.get("/api/models")
+async def list_models():
+    from ..model_registry import format_model_list, get_unique_model_count
+    return {"models": format_model_list(), "count": get_unique_model_count()}
+
+
+class ModelSet(BaseModel):
+    model: str
+
+
+@router.post("/api/models/set")
+async def set_model(data: ModelSet):
+    from ..config import Config
+    c = Config()
+    c.model = data.model
+    c.save()
+    return {"status": "ok", "model": data.model}

luckyd_code/web_routes/static.py

@@ -0,0 +1,70 @@
+"""Static / frontend routes."""
+
+import json
+from pathlib import Path
+
+from fastapi import APIRouter
+from fastapi.responses import HTMLResponse, JSONResponse
+
+router = APIRouter()
+
+TEMPLATES = Path(__file__).resolve().parent.parent / "templates"
+
+
+@router.get("/")
+async def index():
+    path = TEMPLATES / "index.html"
+    if path.exists():
+        return HTMLResponse(
+            path.read_text(encoding="utf-8"),
+            headers={
+                "Cache-Control": "no-store, no-cache, must-revalidate",
+                "Pragma": "no-cache",
+                "Expires": "0",
+            },
+        )
+    return HTMLResponse("<h1>DeepSeek Code Web UI</h1><p>Template not found.</p>")
+
+
+@router.get("/manifest.json")
+async def manifest():
+    path = TEMPLATES / "manifest.json"
+    if path.exists():
+        return JSONResponse(json.loads(path.read_text(encoding="utf-8")))
+    return JSONResponse({}, status_code=404)
+
+
+@router.get("/sw.js")
+async def service_worker():
+    path = TEMPLATES / "sw.js"
+    if path.exists():
+        from fastapi.responses import Response
+        return Response(path.read_bytes(), media_type="application/javascript")
+    return Response(status_code=404)
+
+
+@router.get("/icon-192.png")
+async def icon_192():
+    path = TEMPLATES / "icon-192.png"
+    if path.exists():
+        from fastapi.responses import Response
+        return Response(path.read_bytes(), media_type="image/png")
+    return Response(status_code=404)
+
+
+@router.get("/icon-512.png")
+async def icon_512():
+    path = TEMPLATES / "icon-512.png"
+    if path.exists():
+        from fastapi.responses import Response
+        return Response(path.read_bytes(), media_type="image/png")
+    return Response(status_code=404)
+
+
+@router.get("/favicon.ico")
+async def favicon():
+    path = TEMPLATES / "icon-192.png"
+    if path.exists():
+        from fastapi.responses import Response
+        return Response(path.read_bytes(), media_type="image/png")
+    return Response(status_code=404)

luckyd_code/web_routes/update.py

@@ -0,0 +1,19 @@
+"""Update check and self-update routes."""
+
+from fastapi import APIRouter
+
+from .. import update as updater
+
+router = APIRouter()
+
+
+@router.get("/api/update/check")
+async def check_updates():
+    result = updater.get_version()
+    return {"version": result, "update_available": False}
+
+
+@router.post("/api/update")
+async def do_update():
+    result = updater.do_update()
+    return {"status": "ok", "message": result}