claxcode 0.1.1__py3-none-any.whl

claxcode/__init__.py

@@ -0,0 +1,3 @@
+"""ClaxCode — An agentic coding assistant powered by FastAPI."""
+
+__version__ = "0.1.0"

claxcode/api/__init__.py

@@ -0,0 +1 @@
+"""API routes for ClaxCode."""

claxcode/api/chat.py

@@ -0,0 +1,51 @@
+"""Chat and streaming API."""
+
+import json
+from uuid import UUID
+
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.responses import StreamingResponse
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from claxcode.core.agent import Agent
+from claxcode.memory.session_store import (
+    SessionORM,
+    get_db_session,
+    get_session_messages,
+    save_session_messages,
+)
+from claxcode.models.session import ChatRequest
+
+router = APIRouter()
+
+
+@router.post("/{session_id}/chat")
+async def chat(
+    session_id: UUID,
+    request: ChatRequest,
+    db: AsyncSession = Depends(get_db_session),
+):
+    """Stream chat events via SSE."""
+    result = await db.execute(select(SessionORM).where(SessionORM.id == str(session_id)))
+    row = result.scalar_one_or_none()
+    if row is None:
+        raise HTTPException(status_code=404, detail="会话不存在")
+
+    agent = Agent(
+        session_id=session_id,
+        project_path=row.project_path,
+        permission_mode=row.permission_mode,
+    )
+    agent.context.restore(await get_session_messages(session_id))
+
+    async def event_stream():
+        async for event in agent.run(request.message):
+            yield f"data: {json.dumps(event)}\n\n"
+        # Persist the conversation (minus the system prompt) for the next request
+        await save_session_messages(session_id, agent.context.messages[1:])
+
+    return StreamingResponse(
+        event_stream(),
+        media_type="text/event-stream",
+    )

claxcode/api/session.py

@@ -0,0 +1,66 @@
+"""Session management API."""
+
+from uuid import UUID, uuid4
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from claxcode.memory.session_store import SessionORM, get_db_session
+from claxcode.models.session import Session, SessionCreate
+
+router = APIRouter()
+
+
+def _orm_to_model(orm: SessionORM) -> Session:
+    return Session(
+        id=UUID(orm.id),
+        name=orm.name,
+        project_path=orm.project_path,
+        permission_mode=orm.permission_mode,
+        created_at=orm.created_at,
+        updated_at=orm.updated_at,
+    )
+
+
+@router.post("", response_model=Session)
+async def create_session(
+    data: SessionCreate,
+    db: AsyncSession = Depends(get_db_session),
+):
+    session_orm = SessionORM(
+        id=str(uuid4()),
+        name=data.name,
+        project_path=data.project_path,
+        permission_mode=data.permission_mode,
+    )
+    db.add(session_orm)
+    await db.commit()
+    await db.refresh(session_orm)
+    return _orm_to_model(session_orm)
+
+
+@router.get("", response_model=list[Session])
+async def list_sessions(db: AsyncSession = Depends(get_db_session)):
+    result = await db.execute(select(SessionORM).order_by(SessionORM.created_at.desc()))
+    return [_orm_to_model(row) for row in result.scalars().all()]
+
+
+@router.get("/{session_id}", response_model=Session)
+async def get_session(session_id: UUID, db: AsyncSession = Depends(get_db_session)):
+    result = await db.execute(select(SessionORM).where(SessionORM.id == str(session_id)))
+    row = result.scalar_one_or_none()
+    if row is None:
+        raise HTTPException(status_code=404, detail="会话不存在")
+    return _orm_to_model(row)
+
+
+@router.delete("/{session_id}", status_code=204)
+async def delete_session(session_id: UUID, db: AsyncSession = Depends(get_db_session)):
+    result = await db.execute(select(SessionORM).where(SessionORM.id == str(session_id)))
+    row = result.scalar_one_or_none()
+    if row is None:
+        raise HTTPException(status_code=404, detail="会话不存在")
+    await db.delete(row)
+    await db.commit()
+    return None

claxcode/api/subagents.py

@@ -0,0 +1,82 @@
+"""Subagent management API."""
+
+import asyncio
+import json
+from uuid import UUID
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import StreamingResponse
+
+from claxcode.memory.session_store import (
+    create_subagent_task,
+    finish_subagent_task,
+    get_subagent_task,
+)
+from claxcode.models.subagent import SubagentStatus, SubagentTask
+from claxcode.subagents.executor import ExecutorSubagent
+from claxcode.subagents.explore import ExploreSubagent
+from claxcode.subagents.planner import PlannerSubagent
+
+router = APIRouter()
+
+
+def _spawn_subagent(session_id: UUID, agent_type: str, instruction: str):
+    if agent_type == "explore":
+        return ExploreSubagent(session_id, instruction)
+    if agent_type == "planner":
+        return PlannerSubagent(session_id, instruction)
+    if agent_type == "executor":
+        return ExecutorSubagent(session_id, instruction)
+    raise ValueError(f"未知的代理类型: {agent_type}")
+
+
+@router.post("", response_model=SubagentTask)
+async def spawn_subagent(
+    session_id: UUID,
+    instruction: str,
+    agent_type: str = "explore",
+):
+    task = SubagentTask(
+        session_id=session_id,
+        agent_type=agent_type,
+        instruction=instruction,
+        status=SubagentStatus.RUNNING,
+    )
+    await create_subagent_task(task)
+
+    async def run_task():
+        results = []
+        try:
+            agent = _spawn_subagent(session_id, agent_type, instruction)
+            async for event in agent.run():
+                if event.get("type") == "result":
+                    results.append(event.get("content", ""))
+            await finish_subagent_task(task.id, SubagentStatus.COMPLETED, "\n".join(results))
+        except Exception as exc:
+            await finish_subagent_task(task.id, SubagentStatus.FAILED, str(exc))
+
+    asyncio.create_task(run_task())
+    return task
+
+
+@router.get("/{task_id}", response_model=SubagentTask)
+async def get_subagent(task_id: UUID):
+    task = await get_subagent_task(task_id)
+    if task is None:
+        raise HTTPException(status_code=404, detail="子代理任务不存在")
+    return task
+
+
+@router.post("/{task_id}/stream")
+async def stream_subagent(task_id: UUID):
+    task = await get_subagent_task(task_id)
+    if task is None:
+        raise HTTPException(status_code=404, detail="子代理任务不存在")
+
+    async def event_stream():
+        agent = _spawn_subagent(task.session_id, task.agent_type, task.instruction)
+        async for event in agent.run():
+            yield f"data: {json.dumps(event)}\n\n"
+        yield "data: {\"type\": \"done\"}\n\n"
+
+    return StreamingResponse(event_stream(), media_type="text/event-stream")

claxcode/api/tools.py

@@ -0,0 +1,38 @@
+"""Tool listing and invocation API."""
+
+from fastapi import APIRouter
+
+from claxcode.models.tool import ToolInfo, ToolInvokeRequest, ToolInvokeResponse
+from claxcode.tools.registry import registry
+
+router = APIRouter()
+
+
+@router.get("", response_model=list[ToolInfo])
+async def list_tools():
+    return [
+        ToolInfo(
+            name=tool.name,
+            description=tool.description,
+            input_schema=tool.input_schema,
+            category=tool.category,
+            required_permissions=tool.required_permissions,
+        )
+        for tool in registry.list_tools()
+    ]
+
+
+@router.post("/invoke", response_model=ToolInvokeResponse)
+async def invoke_tool(request: ToolInvokeRequest):
+    tool = registry.get(request.name)
+    if tool is None:
+        return ToolInvokeResponse(
+            name=request.name,
+            output=f"工具 '{request.name}' 不存在",
+            error=True,
+        )
+    try:
+        output = await tool.execute(**request.arguments)
+        return ToolInvokeResponse(name=tool.name, output=str(output))
+    except Exception as exc:
+        return ToolInvokeResponse(name=tool.name, output=str(exc), error=True)