nanoscrypt 0.2.0__py3-none-any.whl

nanoscrypt/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

nanoscrypt/api/__init__.py

@@ -0,0 +1 @@
+# Initialize subpackage

nanoscrypt/api/app.py

@@ -0,0 +1,56 @@
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from nanoscrypt.api.dependencies import get_registry
+from nanoscrypt.api.routers import (
+    agents,
+    approval,
+    audit,
+    health,
+    sessions,
+    tasks,
+    tools,
+)
+from nanoscrypt.logging import setup_logging
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    setup_logging()
+    yield
+    registry = await get_registry()
+    await registry.engine.dispose()
+
+
+def create_app() -> FastAPI:
+    app = FastAPI(
+        title="Nanoscrypt API",
+        description="REST API for the standalone Nanoscrypt tool-synthesis framework",
+        version="0.2.0",
+        lifespan=lifespan,
+    )
+
+    # Enable CORS for frontend integration
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    # Mount API routers under /api/v1 prefix
+    app.include_router(health.router, prefix="/api/v1")
+    app.include_router(sessions.router, prefix="/api/v1")
+    app.include_router(tasks.router, prefix="/api/v1")
+    app.include_router(tools.router, prefix="/api/v1")
+    app.include_router(agents.router, prefix="/api/v1")
+    app.include_router(approval.router, prefix="/api/v1")
+    app.include_router(audit.router, prefix="/api/v1")
+
+    return app
+
+
+app = create_app()

nanoscrypt/api/dependencies.py

@@ -0,0 +1,92 @@
+from nanoscrypt.config.settings import settings
+from nanoscrypt.core.approval import ApprovalGate
+from nanoscrypt.core.audit import AuditLogger
+from nanoscrypt.core.context import ContextBuilder
+from nanoscrypt.core.generator import ToolGenerator
+
+# Enterprise imports v0.2.0
+from nanoscrypt.core.hooks import HookManager
+from nanoscrypt.core.memory import LongTermMemory, ShortTermMemory
+from nanoscrypt.core.orchestrator import Orchestrator
+from nanoscrypt.core.planner import Planner
+from nanoscrypt.core.registry import ToolRegistry
+from nanoscrypt.core.repair import RepairLoop
+from nanoscrypt.core.runtime import RuntimeManager
+from nanoscrypt.core.validator import ToolValidator
+from nanoscrypt.core.versioning import VersionManager
+from nanoscrypt.llm.litellm_provider import LiteLLMProvider
+
+# We cache registry instance globally to prevent re-opening database connections
+_registry: ToolRegistry | None = None
+_orchestrator: Orchestrator | None = None
+
+
+def get_settings():
+    return settings
+
+
+async def get_registry() -> ToolRegistry:
+    global _registry
+    if _registry is None:
+        cfg = get_settings()
+        _registry = ToolRegistry(cfg.registry.database_url)
+        await _registry.initialize_db()
+    return _registry
+
+
+async def get_orchestrator() -> Orchestrator:
+    global _orchestrator
+    if _orchestrator is not None:
+        return _orchestrator
+
+    cfg = get_settings()
+
+    # Initialize LiteLLM wrapper
+    llm = LiteLLMProvider(
+        default_model=cfg.llm.model,
+        temperature=cfg.llm.temperature,
+        max_tokens=cfg.llm.max_tokens,
+    )
+
+    registry = await get_registry()
+
+    context_builder = ContextBuilder(workspace_root="./")  # Scan workspace root
+    planner = Planner(llm=llm)
+    generator = ToolGenerator(llm=llm)
+    validator = ToolValidator(llm=llm)
+    runtime_manager = RuntimeManager(
+        workspace_root=cfg.runtime.workspace_root,
+        timeout_seconds=cfg.runtime.timeout_seconds,
+    )
+    version_manager = VersionManager(tools_dir=cfg.registry.tools_dir)
+
+    repair_loop = RepairLoop(
+        llm=llm,
+        validator=validator,
+        runtime_manager=runtime_manager,
+        max_attempts=cfg.resilience.max_repair_attempts,
+    )
+
+    # Instantiate enterprise helpers
+    hook_manager = HookManager()
+    approval_gate = ApprovalGate()
+    audit_logger = AuditLogger(session_factory=registry.session_factory)
+    short_term_memory = ShortTermMemory(max_entries=cfg.memory.short_term_max_entries)
+    long_term_memory = LongTermMemory(session_factory=registry.session_factory)
+
+    _orchestrator = Orchestrator(
+        context_builder=context_builder,
+        planner=planner,
+        generator=generator,
+        validator=validator,
+        runtime_manager=runtime_manager,
+        registry=registry,
+        version_manager=version_manager,
+        repair_loop=repair_loop,
+        hook_manager=hook_manager,
+        approval_gate=approval_gate,
+        audit_logger=audit_logger,
+        short_term_memory=short_term_memory,
+        long_term_memory=long_term_memory,
+    )
+    return _orchestrator

nanoscrypt/api/routers/__init__.py

@@ -0,0 +1 @@
+# Initialize subpackage

nanoscrypt/api/routers/agents.py

@@ -0,0 +1,94 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy import select
+
+from nanoscrypt.api.dependencies import get_registry
+from nanoscrypt.api.schemas import AgentCreate, AgentPermissionsSchema, AgentResponse
+from nanoscrypt.core.registry import ToolRegistry
+from nanoscrypt.models.database import DBAgentDefinition
+
+router = APIRouter(prefix="/agents", tags=["agents"])
+
+
+@router.post("", response_model=AgentResponse)
+async def create_agent(
+    payload: AgentCreate, registry: ToolRegistry = Depends(get_registry)
+):
+    """Registers a new agent role in the persistent registry database."""
+    async with registry.session_factory() as session:
+        async with session.begin():
+            # Check if name unique
+            stmt = select(DBAgentDefinition).where(
+                DBAgentDefinition.name == payload.name
+            )
+            res = await session.execute(stmt)
+            existing = res.scalar_one_or_none()
+            if existing:
+                raise HTTPException(
+                    status_code=400,
+                    detail=f"Agent with name '{payload.name}' already exists.",
+                )
+
+            agent_db = DBAgentDefinition(
+                name=payload.name,
+                role=payload.role,
+                goal=payload.goal,
+                backstory=payload.backstory,
+                tools=payload.tools,
+                permissions=payload.permissions.model_dump(),
+            )
+            session.add(agent_db)
+            await session.flush()
+
+            return AgentResponse(
+                name=agent_db.name,
+                role=agent_db.role,
+                goal=agent_db.goal,
+                backstory=agent_db.backstory,
+                tools=agent_db.tools,
+                permissions=AgentPermissionsSchema(**agent_db.permissions),
+                created_at=agent_db.created_at,
+            )
+
+
+@router.get("", response_model=list[AgentResponse])
+async def list_agents(registry: ToolRegistry = Depends(get_registry)):
+    """Lists all registered agent configurations."""
+    async with registry.session_factory() as session:
+        stmt = select(DBAgentDefinition)
+        res = await session.execute(stmt)
+        agents = res.scalars().all()
+        response = []
+        for a in agents:
+            response.append(
+                AgentResponse(
+                    name=a.name,
+                    role=a.role,
+                    goal=a.goal,
+                    backstory=a.backstory,
+                    tools=a.tools,
+                    permissions=AgentPermissionsSchema(**a.permissions),
+                    created_at=a.created_at,
+                )
+            )
+        return response
+
+
+@router.get("/{name}", response_model=AgentResponse)
+async def get_agent(name: str, registry: ToolRegistry = Depends(get_registry)):
+    """Retrieves details of a specific agent role configuration."""
+    async with registry.session_factory() as session:
+        stmt = select(DBAgentDefinition).where(DBAgentDefinition.name == name)
+        res = await session.execute(stmt)
+        a = res.scalar_one_or_none()
+        if not a:
+            raise HTTPException(status_code=404, detail=f"Agent '{name}' not found.")
+
+        return AgentResponse(
+            name=a.name,
+            role=a.role,
+            goal=a.goal,
+            backstory=a.backstory,
+            tools=a.tools,
+            permissions=AgentPermissionsSchema(**a.permissions),
+            created_at=a.created_at,
+        )

nanoscrypt/api/routers/approval.py

@@ -0,0 +1,66 @@
+from fastapi import APIRouter, Depends, HTTPException, Query
+
+from nanoscrypt.api.dependencies import get_orchestrator
+from nanoscrypt.api.schemas import ApprovalRecordResponse, ApprovalResolution
+from nanoscrypt.core.approval import ApprovalStatus
+from nanoscrypt.core.orchestrator import Orchestrator
+
+router = APIRouter(prefix="/approvals", tags=["approvals"])
+
+
+@router.get("/pending", response_model=list[ApprovalRecordResponse])
+async def list_pending_approvals(
+    session_id: str | None = Query(
+        None, description="Filter approvals by active session ID"
+    ),
+    orchestrator: Orchestrator = Depends(get_orchestrator),
+):
+    """Lists all active human-in-the-loop pending approval requests."""
+    pending = orchestrator.approval_gate.get_pending(session_id)
+    response = []
+    for r in pending:
+        response.append(
+            ApprovalRecordResponse(
+                id=r.id,
+                session_id=r.session_id,
+                approval_type=r.approval_type.value,
+                description=r.description,
+                risk_level=r.risk_level,
+                resource_details=r.resource_details,
+                agent_name=r.agent_name,
+                status=r.status.value,
+                timestamp=r.timestamp,
+                resolved_at=r.resolved_at,
+                reason=r.reason,
+            )
+        )
+    return response
+
+
+@router.post("/{request_id}/resolve", response_model=dict[str, str])
+async def resolve_approval_request(
+    request_id: str,
+    payload: ApprovalResolution,
+    orchestrator: Orchestrator = Depends(get_orchestrator),
+):
+    """Approves or denies a pending approval request."""
+    if request_id not in orchestrator.approval_gate.pending_requests:
+        raise HTTPException(
+            status_code=404, detail="Pending approval request not found."
+        )
+
+    status = ApprovalStatus.APPROVED if payload.approved else ApprovalStatus.DENIED
+    success = orchestrator.approval_gate.resolve_request(
+        request_id=request_id,
+        status=status,
+        reason=payload.reason or "Resolved via API call.",
+    )
+    if not success:
+        raise HTTPException(
+            status_code=500, detail="Failed to resolve approval request."
+        )
+
+    return {
+        "status": "success",
+        "message": f"Request has been resolved to '{status.value}'.",
+    }

nanoscrypt/api/routers/audit.py

@@ -0,0 +1,67 @@
+from typing import Any
+
+from fastapi import APIRouter, Depends, Query
+from sqlalchemy import select
+
+from nanoscrypt.api.dependencies import get_registry
+from nanoscrypt.api.schemas import AuditLogResponse
+from nanoscrypt.core.registry import ToolRegistry
+from nanoscrypt.models.database import DBAuditLog
+
+router = APIRouter(prefix="/audit", tags=["audit"])
+
+
+@router.get("", response_model=list[AuditLogResponse])
+async def query_audit_logs(
+    session_id: str | None = Query(None, description="Filter logs by session ID"),
+    event_type: str | None = Query(None, description="Filter logs by event type"),
+    limit: int = Query(50, description="Maximum number of log entries to retrieve"),
+    registry: ToolRegistry = Depends(get_registry),
+):
+    """Retrieves immutable audit logs from database with optional filters."""
+    async with registry.session_factory() as session:
+        stmt = select(DBAuditLog)
+
+        # Apply filters
+        if session_id:
+            stmt = stmt.where(DBAuditLog.session_id == session_id)
+        if event_type:
+            stmt = stmt.where(DBAuditLog.event_type == event_type)
+
+        stmt = stmt.order_by(DBAuditLog.timestamp.desc()).limit(limit)
+        res = await session.execute(stmt)
+        logs = res.scalars().all()
+
+        response = []
+        for l in logs:
+            response.append(
+                AuditLogResponse(
+                    id=l.id,
+                    event_type=l.event_type,
+                    session_id=l.session_id,
+                    agent_name=l.agent_name,
+                    details=l.details,
+                    cost=l.cost,
+                    token_usage=l.token_usage,
+                    timestamp=l.timestamp,
+                )
+            )
+        return response
+
+
+@router.get("/summary", response_model=dict[str, Any])
+async def get_audit_summary(registry: ToolRegistry = Depends(get_registry)):
+    """Aggregates costs and token usage totals across all runs."""
+    async with registry.session_factory() as session:
+        stmt = select(DBAuditLog.cost, DBAuditLog.token_usage)
+        res = await session.execute(stmt)
+        records = res.all()
+
+        total_cost = sum(r[0] for r in records)
+        total_tokens = sum(r[1] for r in records)
+
+        return {
+            "total_runs": len(records),
+            "total_estimated_cost_usd": float(total_cost),
+            "total_tokens_consumed": int(total_tokens),
+        }

nanoscrypt/api/routers/health.py

@@ -0,0 +1,12 @@
+from fastapi import APIRouter
+
+router = APIRouter(prefix="/health", tags=["system"])
+
+
+@router.get("")
+def health_check():
+    """
+    Check the health status of the API.
+    Returns a simple JSON response indicating the service is running.
+    """
+    return {"status": "ok", "service": "nanoscrypt-api"}

nanoscrypt/api/routers/sessions.py

@@ -0,0 +1,24 @@
+import uuid
+from datetime import datetime, timezone
+
+from fastapi import APIRouter, Depends
+
+from nanoscrypt.api.dependencies import get_settings
+from nanoscrypt.api.schemas import SessionCreate, SessionResponse
+from nanoscrypt.config.settings import Settings
+
+router = APIRouter(prefix="/sessions", tags=["sessions"])
+
+
+@router.post("", response_model=SessionResponse)
+def create_session(payload: SessionCreate, cfg: Settings = Depends(get_settings)):
+    """
+    Create a new execution session.
+    Allocates a workspace path based on the session ID.
+    """
+    session_id = payload.session_id or f"sess_{uuid.uuid4().hex[:8]}"
+    workspace_path = f"{cfg.runtime.workspace_root}/{session_id}"
+
+    return SessionResponse(
+        id=session_id, workspace_path=workspace_path, created_at=datetime.now(timezone.utc)
+    )

nanoscrypt/api/routers/tasks.py

@@ -0,0 +1,47 @@
+from fastapi import APIRouter, Depends, HTTPException, Query
+
+from nanoscrypt.api.dependencies import get_orchestrator
+from nanoscrypt.api.schemas import TaskResponse, TaskSubmit
+from nanoscrypt.core.orchestrator import Orchestrator
+from nanoscrypt.models.session import Session
+
+router = APIRouter(prefix="/tasks", tags=["tasks"])
+
+
+@router.post("", response_model=TaskResponse)
+async def submit_task(
+    payload: TaskSubmit,
+    session_id: str = Query(
+        ..., description="Active session ID to bound the execution workspace"
+    ),
+    orchestrator: Orchestrator = Depends(get_orchestrator),
+):
+    """
+    Submit a task to be executed by the orchestrator.
+    Requires a session_id to bound the execution workspace.
+    """
+    # Initialize ephemeral session tracking
+    session = Session(id=session_id, workspace_path=f"./workspaces/{session_id}")
+
+    try:
+        result = await orchestrator.execute_task(
+            user_prompt=payload.prompt, session=session
+        )
+
+        # Map execution outcome to target HTTP response format
+        return TaskResponse(
+            status=result.get("status", "error"),
+            action_taken=result.get("action_taken", "none"),
+            tool_name=result.get("tool_name"),
+            version=result.get("version"),
+            output=result.get("output") or result.get("response"),
+            error=result.get("error") or result.get("message"),
+            runtime_ms=result.get("runtime_ms"),
+        )
+    except Exception as e:
+        import logging
+
+        logging.error(f"Task execution failed inside engine: {e!s}")
+        raise HTTPException(
+            status_code=500, detail="An internal error occurred during task execution."
+        )

nanoscrypt/api/routers/tools.py

@@ -0,0 +1,55 @@
+from fastapi import APIRouter, Depends, HTTPException
+
+from nanoscrypt.api.dependencies import get_registry
+from nanoscrypt.api.schemas import ToolResponse
+from nanoscrypt.core.registry import ToolRegistry
+
+router = APIRouter(prefix="/tools", tags=["tools"])
+
+
+@router.get("", response_model=list[ToolResponse])
+async def list_tools(query: str = "", registry: ToolRegistry = Depends(get_registry)):
+    """
+    List or search available tools in the registry.
+    Optional query parameter filters tools by name or description.
+    """
+    tools = await registry.search(query)
+    response = []
+    for t in tools:
+        response.append(
+            ToolResponse(
+                name=t.name,
+                purpose=t.purpose,
+                language=t.language,
+                current_version=t.current_version,
+                success_rate=t.success_rate,
+                usage_count=t.usage_count,
+                status=t.status,
+                created_at=t.created_at,
+            )
+        )
+    return response
+
+
+@router.get("/{name}", response_model=ToolResponse)
+async def get_tool(name: str, registry: ToolRegistry = Depends(get_registry)):
+    """
+    Get a specific tool's details by its name.
+    Returns a 404 error if the tool is not found.
+    """
+    t = await registry.get(name)
+    if not t:
+        raise HTTPException(
+            status_code=404, detail=f"Tool '{name}' not found or inactive in registry."
+        )
+
+    return ToolResponse(
+        name=t.name,
+        purpose=t.purpose,
+        language=t.language,
+        current_version=t.current_version,
+        success_rate=t.success_rate,
+        usage_count=t.usage_count,
+        status=t.status,
+        created_at=t.created_at,
+    )

nanoscrypt/api/schemas.py

@@ -0,0 +1,99 @@
+from datetime import datetime
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class SessionCreate(BaseModel):
+    session_id: str | None = None
+
+
+class SessionResponse(BaseModel):
+    id: str
+    workspace_path: str
+    created_at: datetime
+
+
+class TaskSubmit(BaseModel):
+    prompt: str
+
+
+class TaskResponse(BaseModel):
+    status: str
+    action_taken: str
+    tool_name: str | None = None
+    version: int | None = None
+    output: str | None = None
+    error: str | None = None
+    runtime_ms: int | None = None
+
+
+class ToolResponse(BaseModel):
+    name: str
+    purpose: str
+    language: str
+    current_version: int
+    success_rate: float
+    usage_count: int
+    status: str
+    created_at: datetime
+
+
+# --- ENTERPRISE SCHEMAS V0.2.0 ---
+
+
+class AgentPermissionsSchema(BaseModel):
+    file_system: str = "deny"
+    network: str = "deny"
+    tool_generation: str = "execute"
+    tool_execution: str = "execute"
+    delegation: bool = False
+
+
+class AgentCreate(BaseModel):
+    name: str
+    role: str
+    goal: str
+    backstory: str = ""
+    tools: list[str] = Field(default_factory=list)
+    permissions: AgentPermissionsSchema = Field(default_factory=AgentPermissionsSchema)
+
+
+class AgentResponse(BaseModel):
+    name: str
+    role: str
+    goal: str
+    backstory: str
+    tools: list[str]
+    permissions: AgentPermissionsSchema
+    created_at: datetime
+
+
+class ApprovalRecordResponse(BaseModel):
+    id: str
+    session_id: str
+    approval_type: str
+    description: str
+    risk_level: str
+    resource_details: dict[str, Any]
+    agent_name: str
+    status: str
+    timestamp: datetime
+    resolved_at: datetime | None = None
+    reason: str | None = None
+
+
+class ApprovalResolution(BaseModel):
+    approved: bool
+    reason: str | None = None
+
+
+class AuditLogResponse(BaseModel):
+    id: int
+    event_type: str
+    session_id: str
+    agent_name: str
+    details: dict[str, Any]
+    cost: float
+    token_usage: int
+    timestamp: datetime

nanoscrypt/cli/__init__.py

@@ -0,0 +1 @@
+# Initialize subpackage

nanoscrypt/cli/commands/__init__.py

@@ -0,0 +1 @@
+# Initialize subpackage