codelith 0.1.0__py3-none-any.whl

backend/daemon/launcher.py

@@ -0,0 +1,243 @@
+from __future__ import annotations
+
+import argparse
+import os
+import subprocess
+import sys
+import time
+import urllib.request
+from pathlib import Path
+
+from . import state
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+SERVER_MODULE = "backend.daemon.server"
+HOST = "127.0.0.1"
+DEFAULT_PORT = 8765  # Match the dashboard's hardcoded port
+READY_TIMEOUT_SECONDS = 15.0
+
+
+def _find_venv_python() -> str:
+    """Find the project's venv Python, or fall back to sys.executable."""
+    # Check for .venv in project root
+    venv_python = REPO_ROOT / ".venv" / "Scripts" / "python.exe"
+    if venv_python.exists():
+        return str(venv_python)
+    # Unix
+    venv_python = REPO_ROOT / ".venv" / "bin" / "python"
+    if venv_python.exists():
+        return str(venv_python)
+    return sys.executable
+
+
+def _find_free_port(host: str = HOST, preferred: int = DEFAULT_PORT) -> int:
+    """Try *preferred* port first; fall back to a random free port."""
+    import socket
+
+    # Try preferred port first
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        try:
+            sock.bind((host, preferred))
+            return preferred
+        except OSError:
+            pass  # Port in use, fall back
+
+    # Fall back to random port
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        sock.bind((host, 0))
+        return sock.getsockname()[1]
+
+
+def _wait_until_ready(port: int, timeout: float = READY_TIMEOUT_SECONDS) -> bool:
+    """Poll the daemon's /health endpoint until it responds or we time out."""
+    url = f"http://{HOST}:{port}/health"
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        try:
+            with urllib.request.urlopen(url, timeout=1.0) as resp:
+                if resp.status == 200:
+                    return True
+        except OSError:
+            pass
+        time.sleep(0.2)
+    return False
+
+
+def open_dashboard(port: int = DEFAULT_PORT) -> bool:
+    """Open the dashboard in the default browser. True on success.
+
+    Call only once the daemon is confirmed ready: ``start`` guarantees
+    that for a fresh start (it polls /health), and an adopted port is
+    answering by definition.
+    """
+    url = f"http://localhost:{port}/"
+    try:
+        import webbrowser
+
+        return webbrowser.open(url, new=2, autoraise=True)
+    except Exception:  # noqa: BLE001 - a browser failure must not kill the CLI
+        return False
+
+
+def _daemon_command(port: int) -> tuple[list[str], dict[str, str]]:
+    """Return ``(argv, env)`` for the detached daemon process.
+
+    Detects the project's venv Python so the daemon always has access to
+    installed packages, regardless of which Python was used to invoke the
+    launcher.
+    """
+    env = dict(os.environ)
+    python = _find_venv_python()
+    argv = [python, "-m", SERVER_MODULE, "--host", HOST, "--port", str(port)]
+    return argv, env
+
+
+def _start_detached(port: int) -> subprocess.Popen:
+    """Spawn the daemon server in a detached process with its own session."""
+    state.ensure_state_dir()
+    log = (state.state_dir() / "daemon.log").open("a", encoding="utf-8")
+    argv, env = _daemon_command(port)
+    kwargs: dict = {
+        "cwd": str(REPO_ROOT),
+        "env": env,
+        "stdin": subprocess.DEVNULL,
+        "stdout": log,
+        "stderr": subprocess.STDOUT,
+    }
+    if sys.platform == "win32":
+        # Hide the console window without using DETACHED_PROCESS
+        # (DETACHED_PROCESS can break subprocess environment on Windows).
+        si = subprocess.STARTUPINFO()
+        si.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+        si.wShowWindow = 0  # SW_HIDE
+        kwargs["startupinfo"] = si
+        kwargs["creationflags"] = subprocess.CREATE_NEW_PROCESS_GROUP
+    else:
+        kwargs["start_new_session"] = True
+    return subprocess.Popen(argv, **kwargs)
+
+
+def start() -> tuple[int, int, bool]:
+    """Start the daemon if necessary, or adopt an already-running one.
+
+    The "already running" check is port-based (127.0.0.1:<default port>
+    accepting connections): if something healthy answers on the dashboard
+    port, reuse it instead of starting a second daemon. A stale pid file
+    pointing at a dead process — or at a port nobody listens on — must
+    never cause a duplicate daemon. Quiet on the already-running paths;
+    callers decide what to show the user (the CLI prints a dashboard
+    link instead of daemon bookkeeping).
+
+    Returns ``(pid, port, started_now)``; ``pid`` is ``None`` for an
+    adopted daemon this process did not spawn.
+    """
+    running = state.is_running()
+    if running:
+        pid, port = running
+        return pid, port, False
+
+    # Something already serves the dashboard port (e.g. a daemon started
+    # elsewhere, with pid state this install can't see) → adopt it rather
+    # than spawn a rival that would lose the port race anyway.
+    if state.port_open(DEFAULT_PORT):
+        return None, DEFAULT_PORT, False
+
+    # Clear stale state left behind by a crashed or stopped daemon.
+    state.clear_state()
+
+    port = _find_free_port()
+    proc = _start_detached(port)
+    state.write_state(proc.pid, port)
+    if not _wait_until_ready(port):
+        _print_log_tail()
+        raise SystemExit(
+            f"Daemon failed to become ready within {READY_TIMEOUT_SECONDS:.0f}s; "
+            f"see {state.state_dir() / 'daemon.log'}"
+        )
+    return proc.pid, port, True
+
+
+def status() -> None:
+    """Print whether the daemon is running and its PID/port."""
+    running = state.is_running()
+    if running:
+        pid, port = running
+        print(f"Daemon is running (pid {pid}, port {port}).")
+        return
+    pid = state.read_pid()
+    port = state.read_port()
+    if pid is not None or port is not None:
+        print(f"Daemon is not running (stale state: pid={pid}, port={port}).")
+    else:
+        print("Daemon is not running.")
+
+
+def _terminate(pid: int) -> None:
+    if sys.platform == "win32":
+        subprocess.run(
+            ["taskkill", "/PID", str(pid), "/F"],
+            check=False,
+            capture_output=True,
+        )
+    else:
+        import os
+        import signal
+
+        os.kill(pid, signal.SIGTERM)
+
+
+def stop() -> bool:
+    """Stop the running daemon and clear its state. Returns True if one was running."""
+    pid = state.read_pid()
+    if pid is None:
+        print("No daemon state found; nothing to stop.")
+        return False
+    if state.pid_alive(pid):
+        _terminate(pid)
+        print(f"Stopped daemon (pid {pid}).")
+    else:
+        print(f"State refers to dead pid {pid}; cleaning up.")
+    state.clear_state()
+    return True
+
+
+def _print_log_tail() -> None:
+    log = state.state_dir() / "daemon.log"
+    try:
+        tail = "\n".join(log.read_text(encoding="utf-8").splitlines()[-20:])
+    except OSError:
+        return
+    if tail:
+        print("--- daemon.log tail ---")
+        print(tail)
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(
+        prog="codelith-daemon",
+        description="Manage the CodeLith local daemon.",
+    )
+    parser.add_argument("command", choices=["start", "status", "stop", "open"])
+    args = parser.parse_args(argv)
+
+    if args.command == "start":
+        pid, port, started = start()
+        # Bookkeeping belongs in this explicit management entrypoint; the
+        # chat flow (cli.main) prints a dashboard link instead.
+        if started:
+            print(f"Daemon started (pid {pid}, port {port}).")
+        elif pid is not None:
+            print(f"Daemon already running (pid {pid}, port {port}).")
+        else:
+            print(f"Port {port} is already serving the dashboard; reusing it.")
+    elif args.command == "status":
+        status()
+    elif args.command == "stop":
+        stop()
+    elif args.command == "open":
+        _pid, port, _started = start()
+        open_dashboard(port)
+
+
+if __name__ == "__main__":
+    main()

backend/daemon/server.py

@@ -0,0 +1,453 @@
+from __future__ import annotations
+
+import argparse
+import json
+import queue
+import threading
+from pathlib import Path
+from typing import Optional
+
+import uvicorn
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel, Field
+
+from backend.orchestrator.graph import run_graph
+from backend.orchestrator.modes import list_modes
+from backend.database.concepts import (
+    load_concepts,
+    get_progress,
+    clear_concepts,
+    clear_assessments,
+    clear_teachings,
+    get_pending_assessments,
+    get_all_assessments,
+    get_assessment_counts,
+    submit_assessment_answer,
+    get_assessment_progress,
+    get_teachings,
+)
+
+DEFAULT_HOST = "127.0.0.1"
+DEFAULT_PORT = 8765
+
+# Built dashboard, shipped inside the package (frontend's Vite build
+# writes here directly — see frontend/vite.config.ts).  Anchored to
+# this module's location, never the process CWD: after `pip install
+# codelith` the daemon may be started from any directory, and a
+# relative "static" would either crash at startup or silently serve
+# the wrong folder.
+STATIC_DIR = Path(__file__).resolve().parent / "static"
+
+app = FastAPI(title="CodeLith Daemon")
+
+# Allow the Vite dev server (and any localhost origin) to call our API.
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# In-memory conversation history keyed by session id.
+# A new CLI session always sends "new_session" first, then subsequent
+# messages carry the same session id so context is preserved.
+_conversations: dict[str, list[dict]] = {}
+MAX_HISTORY_TURNS = 4  # keep last N user+assistant pairs to stay within TPM limits
+
+# In-memory session modes keyed by session id.  The daemon is the source of
+# truth so the CLI and the dashboard always agree on the active mode:
+# either client can change it and the other picks the change up.
+_session_modes: dict[str, str] = {}
+
+
+class ChatMessage(BaseModel):
+    """Payload accepted by the chat endpoint."""
+
+    message: str = ""
+    workspace: str = ""  # user's project root
+    session: str = "default"  # conversation session id
+    mode: str = "learn"  # session mode: learn, pair-programming, autonomous
+
+
+class QuestionMessage(BaseModel):
+    """A user question for the dashboard chat."""
+
+    question: str = ""
+    session: str = "default"
+    history: list[dict] = Field(default_factory=list)
+
+
+class AssessmentAnswer(BaseModel):
+    """An answer to an assessment question."""
+
+    assessment_id: str
+    answer: str
+    session: str = "default"
+
+
+class ModeChange(BaseModel):
+    """Payload for POST /mode (mode switch from CLI or dashboard)."""
+
+    mode: str = ""
+    session: str = "default"
+
+
+@app.get("/health")
+def health() -> dict:
+    """Liveness probe."""
+    return {"status": "ok"}
+
+
+@app.post("/chat")
+def chat(payload: Optional[ChatMessage] = None) -> dict:
+    """Chat endpoint: forward the message (with history) to the graph."""
+    if payload is None:
+        return {"message": "", "session": "default"}
+
+    text = payload.message
+    workspace = payload.workspace or None
+    session_id = payload.session or "default"
+    # The daemon's stored mode wins: the CLI and dashboard may send stale
+    # local state, and both hit the same session.
+    mode = _session_modes.get(session_id, payload.mode or "learn")
+
+    # Append the new user message to this session's history.
+    history = _conversations.setdefault(session_id, [])
+    history.append({"role": "user", "content": text})
+
+    # Trim history to stay within TPM limits (keep last N pairs)
+    if len(history) > MAX_HISTORY_TURNS * 2:
+        history[:] = history[-MAX_HISTORY_TURNS * 2:]
+
+    result = run_graph(
+        text,
+        workspace_root=workspace,
+        history=history,
+        mode=mode,
+        session=session_id,
+    )
+
+    # Store the assistant reply so the next turn sees it.
+    history.append({"role": "assistant", "content": result["reply"]})
+
+    return {
+        "message": result["reply"],
+        "session": session_id,
+        "concepts": result.get("concepts", []),
+        "teaching": result.get("teaching", ""),
+        "tool_calls_log": result.get("tool_calls_log", []),
+    }
+
+
+# --- Dashboard API endpoints ------------------------------------------------
+
+
+@app.post("/chat/stream")
+def chat_stream(payload: Optional[ChatMessage] = None) -> StreamingResponse:
+    """Streaming chat endpoint (SSE).
+
+    Pushes live activity events while the agent works, then the final
+    result.  Each SSE ``data:`` line is a JSON object with a ``type``:
+
+    - ``node``       — a graph node started (coding_agent, teacher_agent, ...)
+    - ``status``     — a short status line (e.g. "Thinking…")
+    - ``tool_start`` — a tool call began ({tool, detail})
+    - ``tool_done``  — the tool finished ({tool, detail, ok})
+    - ``result``     — the final chat payload (same shape as POST /chat)
+    - ``error``      — the graph run failed
+    """
+    if payload is None:
+        payload = ChatMessage()
+
+    text = payload.message
+    workspace = payload.workspace or None
+    session_id = payload.session or "default"
+    mode = payload.mode or "learn"
+
+    # Append the new user message to this session's history.
+    history = _conversations.setdefault(session_id, [])
+    history.append({"role": "user", "content": text})
+    if len(history) > MAX_HISTORY_TURNS * 2:
+        history[:] = history[-MAX_HISTORY_TURNS * 2:]
+
+    events: queue.Queue = queue.Queue()
+    SENTINEL = object()
+
+    def _sink(event: dict) -> None:
+        events.put(event)
+
+    def _run_graph() -> None:
+        try:
+            result = run_graph(
+                text,
+                workspace_root=workspace,
+                history=history,
+                mode=mode,
+                session=session_id,
+                event_sink=_sink,
+            )
+            # Mirror POST /chat: store the assistant reply so the next
+            # turn sees it, and send the final result through the queue.
+            history.append({"role": "assistant", "content": result["reply"]})
+            events.put({
+                "type": "result",
+                "message": result["reply"],
+                "session": session_id,
+                "concepts": result.get("concepts", []),
+                "teaching": result.get("teaching", ""),
+                "tool_calls_log": result.get("tool_calls_log", []),
+            })
+        except Exception as exc:  # noqa: BLE001 — streamed to the client
+            events.put({"type": "error", "message": str(exc)})
+        finally:
+            events.put(SENTINEL)
+
+    worker = threading.Thread(target=_run_graph, daemon=True)
+
+    def _generate():
+        worker.start()
+        try:
+            while True:
+                try:
+                    item = events.get(timeout=120.0)
+                except queue.Empty:
+                    yield "data: {\"type\": \"error\", \"message\": \"agent timed out\"}\n\n"
+                    break
+                if item is SENTINEL:
+                    break
+                yield f"data: {json.dumps(item)}\n\n"
+        finally:
+            worker.join(timeout=1.0)
+
+    return StreamingResponse(
+        _generate(),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "X-Accel-Buffering": "no",
+            "Connection": "keep-alive",
+        },
+    )
+
+
+@app.get("/modes")
+def modes() -> dict:
+    """Return available session modes."""
+    return {"modes": list_modes()}
+
+
+@app.get("/mode")
+def get_mode_endpoint(session: str = "default") -> dict:
+    """Return the active session mode for *session*."""
+    from backend.orchestrator.modes import DEFAULT_MODE
+
+    return {"mode": _session_modes.get(session, DEFAULT_MODE)}
+
+
+@app.post("/mode")
+def set_mode_endpoint(payload: Optional[ModeChange] = None) -> dict:
+    """Set the active session mode.
+
+    Accepts ``{"mode": "learn", "session": "default"}`` from either the
+    CLI (``mode <name>``) or the dashboard.  Every subsequent chat turn in
+    that session runs in the new mode, whichever client sent it.
+    """
+    from backend.orchestrator.modes import get_mode
+
+    if payload is None:
+        return {"status": "error", "message": "No payload provided"}
+
+    mode = (payload.mode or "").strip()
+    session = payload.session or "default"
+    if get_mode(mode).name != mode:
+        return {"status": "error", "message": f"Unknown mode: {mode}"}
+
+    _session_modes[session] = mode
+    return {"status": "ok", "mode": mode, "session": session}
+
+
+@app.get("/concepts")
+def concepts(session: str = "default") -> dict:
+    """Return all stored concepts for a session."""
+    return {"concepts": load_concepts(session)}
+
+
+@app.get("/progress")
+def progress(session: str = "default") -> dict:
+    """Return learning progress summary for a session."""
+    return get_progress(session)
+
+
+@app.post("/question")
+def question(payload: Optional[QuestionMessage] = None) -> dict:
+    """Answer a user question using the LLM (without file operations)."""
+    from backend.llm.client import generate_reply
+
+    if payload is None:
+        return {"answer": ""}
+
+    question_text = payload.question
+    if not question_text.strip():
+        return {"answer": "Please ask a question."}
+
+    answer = generate_reply(question_text, history=payload.history)
+    return {"answer": answer}
+
+
+@app.delete("/concepts")
+def delete_concepts(session: str = "default") -> dict:
+    """Clear all stored concepts for a session."""
+    clear_concepts(session)
+    return {"status": "cleared"}
+
+
+@app.delete("/assessments")
+def delete_assessments(session: str = "default") -> dict:
+    """Clear all stored assessments for a session."""
+    clear_assessments(session)
+    return {"status": "cleared"}
+
+
+@app.delete("/teachings")
+def delete_teachings(session: str = "default") -> dict:
+    """Clear all stored teachings for a session."""
+    clear_teachings(session)
+    return {"status": "cleared"}
+
+
+# --- Assessment endpoints --------------------------------------------------
+
+
+@app.get("/assessments")
+def assessments(session: str = "default") -> dict:
+    """Return all assessments (pending and answered) for a session."""
+    return {
+        "assessments": get_all_assessments(session),
+        "counts": get_assessment_counts(session),
+    }
+
+
+@app.get("/assessments/pending")
+def pending_assessments(session: str = "default") -> dict:
+    """Return the current (first unanswered) assessment for a session."""
+    return {
+        "assessments": get_pending_assessments(session),
+        "counts": get_assessment_counts(session),
+    }
+
+
+@app.post("/assessments/answer")
+def answer_assessment(payload: Optional[AssessmentAnswer] = None) -> dict:
+    """Grade and record an answer to an assessment question.
+
+    Grading happens server-side via the LLM; the client-provided verdict
+    is ignored.  Correct answers close the question; incorrect ones keep
+    it open with feedback so the learner can retry.
+    """
+    if payload is None:
+        return {"status": "error", "message": "No payload provided"}
+
+    assessments = get_all_assessments(payload.session)
+    assessment = next(
+        (a for a in assessments if a.get("id") == payload.assessment_id), None
+    )
+    if assessment is None:
+        return {"status": "error", "message": "Assessment not found"}
+
+    from backend.llm.client import grade_answer
+
+    grade = grade_answer(
+        question=assessment.get("question", ""),
+        answer=payload.answer,
+        concept_name=assessment.get("concept_name", ""),
+        concept_category=assessment.get("concept_category", ""),
+    )
+
+    result = submit_assessment_answer(
+        session=payload.session,
+        assessment_id=payload.assessment_id,
+        answer=payload.answer,
+        correct=grade["correct"],
+        feedback=grade["feedback"],
+    )
+
+    if result is None:  # pragma: no cover - assessment existed a moment ago
+        return {"status": "error", "message": "Assessment not found"}
+    return {
+        "status": "ok",
+        "assessment": result,
+        "correct": grade["correct"],
+        "feedback": grade["feedback"],
+    }
+
+
+@app.get("/assessments/progress")
+def assessment_progress(session: str = "default") -> dict:
+    """Return assessment performance summary."""
+    return get_assessment_progress(session)
+
+
+# --- Teaching endpoints (for dashboard) ------------------------------------
+# NOTE: these must stay ABOVE the catch-all static mount at the bottom
+# of this module.  FastAPI matches routes in registration order, so a
+# mount registered first shadows every route defined after it — GET
+# /teachings silently 404'd that way and diagrams vanished from the
+# dashboard (see tests/daemon/test_route_order.py).
+
+
+@app.get("/teachings")
+def teachings(session: str = "default") -> dict:
+    """Return all teaching entries for a session."""
+    return {"teachings": get_teachings(session)}
+
+
+@app.websocket("/ws")
+async def websocket_endpoint(websocket: WebSocket) -> None:
+    """Stub WebSocket endpoint: accept connections and echo messages back."""
+    await websocket.accept()
+    try:
+        while True:
+            message = await websocket.receive_text()
+            await websocket.send_text(message)
+    except WebSocketDisconnect:
+        pass
+
+
+# --- Dashboard static serving (always LAST) --------------------------------
+
+# Mounted AFTER every API route so API paths always win, and only when
+# the built dashboard is present: a source checkout without `npm run
+# build` (or a dev workflow using the Vite server) runs API-only with
+# a logged note instead of crashing the daemon at import time.
+if STATIC_DIR.is_dir():
+    from fastapi.staticfiles import StaticFiles
+
+    app.mount("/", StaticFiles(directory=STATIC_DIR, html=True), name="dashboard")
+else:
+    import sys
+
+    print(
+        "[codelith] dashboard build not found — running API-only. "
+        "Run `npm run build` in frontend/ to serve the dashboard from the daemon.",
+        file=sys.stderr,
+    )
+
+
+def run(host: str = DEFAULT_HOST, port: int = DEFAULT_PORT) -> None:
+    """Serve the daemon app."""
+    uvicorn.run(app, host=host, port=port)
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(description="CodeLith local daemon server")
+    parser.add_argument("--host", default=DEFAULT_HOST, help=f"bind host (default: {DEFAULT_HOST})")
+    parser.add_argument("--port", type=int, default=DEFAULT_PORT, help=f"bind port (default: {DEFAULT_PORT})")
+    args = parser.parse_args(argv)
+    run(host=args.host, port=args.port)
+
+
+if __name__ == "__main__":
+    main()