init commit

backend/app/routers/layouts.py

@@ -0,0 +1,102 @@
+import json
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+
+from ..auth import verify_token
+from ..database import get_db
+from ..models import GraphLayout
+from ..schemas import (
+    GraphLayoutCreate,
+    GraphLayoutDetailResponse,
+    GraphLayoutResponse,
+    GraphLayoutUpdate,
+)
+
+router = APIRouter(prefix="/api/layouts", tags=["layouts"], dependencies=[Depends(verify_token)])
+
+
+def _to_response(layout: GraphLayout) -> GraphLayoutResponse:
+    return GraphLayoutResponse.model_validate(layout)
+
+
+def _to_detail_response(layout: GraphLayout) -> GraphLayoutDetailResponse:
+    base = GraphLayoutResponse.model_validate(layout)
+    return GraphLayoutDetailResponse(
+        **base.model_dump(),
+        node_positions=json.loads(layout.node_positions),
+        viewport=json.loads(layout.viewport),
+    )
+
+
+@router.get("", response_model=list[GraphLayoutResponse])
+def list_layouts(project_id: int | None = None, db: Session = Depends(get_db)):
+    query = db.query(GraphLayout)
+    if project_id is not None:
+        query = query.filter(GraphLayout.project_id == project_id)
+    return [_to_response(l) for l in query.order_by(GraphLayout.updated_at.desc()).all()]
+
+
+@router.get("/{layout_id}", response_model=GraphLayoutDetailResponse)
+def get_layout(layout_id: int, db: Session = Depends(get_db)):
+    layout = db.get(GraphLayout, layout_id)
+    if not layout:
+        raise HTTPException(404, "Layout not found")
+    return _to_detail_response(layout)
+
+
+@router.post("", response_model=GraphLayoutDetailResponse, status_code=201)
+def create_layout(data: GraphLayoutCreate, db: Session = Depends(get_db)):
+    if data.is_default:
+        db.query(GraphLayout).filter(
+            GraphLayout.project_id == data.project_id
+        ).update({"is_default": False})
+
+    layout = GraphLayout(
+        name=data.name,
+        description=data.description,
+        project_id=data.project_id,
+        node_positions=json.dumps(data.node_positions),
+        viewport=json.dumps(data.viewport),
+        is_default=data.is_default,
+    )
+    db.add(layout)
+    db.commit()
+    db.refresh(layout)
+    return _to_detail_response(layout)
+
+
+@router.put("/{layout_id}", response_model=GraphLayoutDetailResponse)
+def update_layout(layout_id: int, data: GraphLayoutUpdate, db: Session = Depends(get_db)):
+    layout = db.get(GraphLayout, layout_id)
+    if not layout:
+        raise HTTPException(404, "Layout not found")
+
+    update_data = data.model_dump(exclude_unset=True)
+
+    if update_data.get("is_default"):
+        db.query(GraphLayout).filter(
+            GraphLayout.project_id == layout.project_id,
+            GraphLayout.id != layout_id,
+        ).update({"is_default": False})
+
+    if "node_positions" in update_data:
+        update_data["node_positions"] = json.dumps(update_data["node_positions"])
+    if "viewport" in update_data:
+        update_data["viewport"] = json.dumps(update_data["viewport"])
+
+    for key, value in update_data.items():
+        setattr(layout, key, value)
+
+    db.commit()
+    db.refresh(layout)
+    return _to_detail_response(layout)
+
+
+@router.delete("/{layout_id}", status_code=204)
+def delete_layout(layout_id: int, db: Session = Depends(get_db)):
+    layout = db.get(GraphLayout, layout_id)
+    if not layout:
+        raise HTTPException(404, "Layout not found")
+    db.delete(layout)
+    db.commit()

backend/app/routers/links.py

@@ -0,0 +1,55 @@
+from typing import Optional
+
+from fastapi import APIRouter, Depends, HTTPException, Query
+from sqlalchemy import or_
+from sqlalchemy.orm import Session
+
+from ..auth import verify_token
+from ..database import get_db
+from ..models import CrossPillarLink, RequirementNode
+from ..schemas import LinkCreate, LinkResponse
+
+router = APIRouter(prefix="/api/links", tags=["links"], dependencies=[Depends(verify_token)])
+
+
+@router.get("", response_model=list[LinkResponse])
+def list_links(
+    node_id: Optional[str] = Query(None, description="Filter links involving this node"),
+    db: Session = Depends(get_db),
+):
+    q = db.query(CrossPillarLink)
+    if node_id:
+        q = q.filter(
+            or_(
+                CrossPillarLink.source_id == node_id,
+                CrossPillarLink.target_id == node_id,
+            )
+        )
+    return q.all()
+
+
+@router.post("", response_model=LinkResponse, status_code=201)
+def create_link(data: LinkCreate, db: Session = Depends(get_db)):
+    if not db.get(RequirementNode, data.source_id):
+        raise HTTPException(404, f"Source {data.source_id} not found")
+    if not db.get(RequirementNode, data.target_id):
+        raise HTTPException(404, f"Target {data.target_id} not found")
+
+    existing = db.get(CrossPillarLink, (data.source_id, data.target_id))
+    if existing:
+        raise HTTPException(409, "Link already exists")
+
+    link = CrossPillarLink(**data.model_dump())
+    db.add(link)
+    db.commit()
+    db.refresh(link)
+    return link
+
+
+@router.delete("/{source_id}/{target_id}", status_code=204)
+def delete_link(source_id: str, target_id: str, db: Session = Depends(get_db)):
+    link = db.get(CrossPillarLink, (source_id, target_id))
+    if not link:
+        raise HTTPException(404, "Link not found")
+    db.delete(link)
+    db.commit()

backend/app/routers/projects.py

@@ -0,0 +1,40 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+
+from ..auth import verify_token
+from ..database import get_db
+from ..models import Project
+from ..schemas import ProjectCreate, ProjectResponse
+
+router = APIRouter(prefix="/api/projects", tags=["projects"], dependencies=[Depends(verify_token)])
+
+
+@router.get("", response_model=list[ProjectResponse])
+def list_projects(db: Session = Depends(get_db)):
+    return db.query(Project).all()
+
+
+@router.post("", response_model=ProjectResponse, status_code=201)
+def create_project(data: ProjectCreate, db: Session = Depends(get_db)):
+    project = Project(**data.model_dump())
+    db.add(project)
+    db.commit()
+    db.refresh(project)
+    return project
+
+
+@router.get("/{project_id}", response_model=ProjectResponse)
+def get_project(project_id: int, db: Session = Depends(get_db)):
+    project = db.get(Project, project_id)
+    if not project:
+        raise HTTPException(404, f"Project {project_id} not found")
+    return project
+
+
+@router.delete("/{project_id}", status_code=204)
+def delete_project(project_id: int, db: Session = Depends(get_db)):
+    project = db.get(Project, project_id)
+    if not project:
+        raise HTTPException(404, f"Project {project_id} not found")
+    db.delete(project)
+    db.commit()

backend/app/routers/requirements.py

@@ -0,0 +1,252 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy import func
+from sqlalchemy.orm import Session
+
+from ..auth import verify_token
+from ..database import get_db
+from ..models import RequirementNode, RequirementHistory
+from ..quality import validate_requirement
+from ..schemas import (
+    RequirementCreate,
+    RequirementResponse,
+    RequirementTreeNode,
+    RequirementUpdate,
+    QualityReport,
+    RequirementHistorySummary,
+    RequirementHistoryDetail,
+)
+
+router = APIRouter(prefix="/api/requirements", tags=["requirements"], dependencies=[Depends(verify_token)])
+
+# ─── Snapshot fields to copy between RequirementNode and RequirementHistory ───
+_SNAPSHOT_FIELDS = [
+    "title", "description", "priority", "phase", "status", "node_type",
+    "acceptance_criteria", "test_spec", "test_code", "impl_code",
+    "code_language", "target_test_file", "target_impl_file",
+    "measurable", "consistent", "single_purpose",
+    "gitea_issue_number", "gitea_repo",
+]
+
+
+def _create_history_entry(
+    db: Session, node: RequirementNode, version: int, summary: str | None = None
+) -> RequirementHistory:
+    data = {field: getattr(node, field) for field in _SNAPSHOT_FIELDS}
+    # Convert enums to their string values for plain String columns
+    for key in ("priority", "status", "node_type", "code_language"):
+        val = data.get(key)
+        if val is not None and hasattr(val, "value"):
+            data[key] = val.value
+    entry = RequirementHistory(
+        requirement_id=node.id,
+        version=version,
+        change_summary=summary,
+        **data,
+    )
+    db.add(entry)
+    return entry
+
+
+def _next_version(db: Session, req_id: str) -> int:
+    max_ver = db.query(func.max(RequirementHistory.version)).filter(
+        RequirementHistory.requirement_id == req_id
+    ).scalar()
+    return (max_ver or 0) + 1
+
+
+def _auto_summary(update_data: dict) -> str:
+    fields = [k for k in update_data if k in _SNAPSHOT_FIELDS]
+    if not fields:
+        return "Update"
+    return "Updated " + ", ".join(fields)
+
+
+def _to_response(node: RequirementNode, include_children: bool = False) -> RequirementResponse:
+    quality = validate_requirement(node, node.children)
+    resp = RequirementResponse.model_validate(node)
+    resp.quality = quality
+    if include_children:
+        resp.children = [_to_response(c) for c in node.children]
+    return resp
+
+
+def _to_tree_node(node: RequirementNode) -> RequirementTreeNode:
+    quality = validate_requirement(node, node.children)
+    return RequirementTreeNode(
+        id=node.id,
+        title=node.title,
+        priority=node.priority,
+        phase=node.phase,
+        status=node.status,
+        node_type=node.node_type,
+        parent_id=node.parent_id,
+        child_count=len(node.children),
+        traceable=quality.traceable,
+        measurable=quality.measurable,
+        consistent=node.consistent,
+        single_purpose=node.single_purpose,
+        gitea_issue_number=node.gitea_issue_number,
+        children=[_to_tree_node(c) for c in node.children],
+    )
+
+
+@router.get("", response_model=list[RequirementResponse])
+def list_requirements(
+    project_id: int | None = None,
+    parent_id: str | None = None,
+    db: Session = Depends(get_db),
+):
+    query = db.query(RequirementNode)
+    if project_id is not None:
+        query = query.filter(RequirementNode.project_id == project_id)
+    if parent_id is not None:
+        query = query.filter(RequirementNode.parent_id == parent_id)
+    nodes = query.order_by(RequirementNode.sort_order).all()
+    return [_to_response(n) for n in nodes]
+
+
+@router.get("/tree", response_model=list[RequirementTreeNode])
+def get_tree(project_id: int | None = None, db: Session = Depends(get_db)):
+    query = db.query(RequirementNode).filter(RequirementNode.parent_id.is_(None))
+    if project_id is not None:
+        query = query.filter(RequirementNode.project_id == project_id)
+    roots = query.order_by(RequirementNode.sort_order).all()
+    return [_to_tree_node(r) for r in roots]
+
+
+@router.get("/{req_id}", response_model=RequirementResponse)
+def get_requirement(req_id: str, db: Session = Depends(get_db)):
+    node = db.get(RequirementNode, req_id)
+    if not node:
+        raise HTTPException(404, f"Requirement {req_id} not found")
+    return _to_response(node, include_children=True)
+
+
+@router.post("", response_model=RequirementResponse, status_code=201)
+def create_requirement(data: RequirementCreate, db: Session = Depends(get_db)):
+    if db.get(RequirementNode, data.id):
+        raise HTTPException(409, f"Requirement {data.id} already exists")
+    if data.parent_id and not db.get(RequirementNode, data.parent_id):
+        raise HTTPException(404, f"Parent {data.parent_id} not found")
+
+    node = RequirementNode(**data.model_dump())
+
+    # Auto-compute traceable flag only
+    quality = validate_requirement(node, [])
+    node.traceable = quality.traceable
+
+    db.add(node)
+    db.flush()
+    _create_history_entry(db, node, version=1, summary="Initial version")
+    db.commit()
+    db.refresh(node)
+    return _to_response(node)
+
+
+@router.put("/{req_id}", response_model=RequirementResponse)
+def update_requirement(req_id: str, data: RequirementUpdate, db: Session = Depends(get_db)):
+    node = db.get(RequirementNode, req_id)
+    if not node:
+        raise HTTPException(404, f"Requirement {req_id} not found")
+
+    update_data = data.model_dump(exclude_unset=True)
+    for key, value in update_data.items():
+        setattr(node, key, value)
+
+    # Auto-compute traceable flag only (M, C, S are user-set toggles)
+    quality = validate_requirement(node, node.children)
+    node.traceable = quality.traceable
+
+    version = _next_version(db, req_id)
+    _create_history_entry(db, node, version, _auto_summary(update_data))
+
+    db.commit()
+    db.refresh(node)
+    return _to_response(node, include_children=True)
+
+
+@router.delete("/{req_id}", status_code=204)
+def delete_requirement(req_id: str, db: Session = Depends(get_db)):
+    node = db.get(RequirementNode, req_id)
+    if not node:
+        raise HTTPException(404, f"Requirement {req_id} not found")
+    db.delete(node)
+    db.commit()
+
+
+@router.patch("/{req_id}/status")
+def update_status(req_id: str, status: str, db: Session = Depends(get_db)):
+    node = db.get(RequirementNode, req_id)
+    if not node:
+        raise HTTPException(404, f"Requirement {req_id} not found")
+    node.status = status
+    db.commit()
+    return {"id": req_id, "status": status}
+
+
+@router.post("/{req_id}/validate", response_model=QualityReport)
+def validate_node(req_id: str, db: Session = Depends(get_db)):
+    node = db.get(RequirementNode, req_id)
+    if not node:
+        raise HTTPException(404, f"Requirement {req_id} not found")
+    return validate_requirement(node, node.children)
+
+
+@router.get("/{req_id}/children", response_model=list[RequirementResponse])
+def get_children(req_id: str, db: Session = Depends(get_db)):
+    node = db.get(RequirementNode, req_id)
+    if not node:
+        raise HTTPException(404, f"Requirement {req_id} not found")
+    return [_to_response(c) for c in node.children]
+
+
+# ─── History Endpoints ────────────────────────────────────────────────────
+
+@router.get("/{req_id}/history", response_model=list[RequirementHistorySummary])
+def get_history(req_id: str, db: Session = Depends(get_db)):
+    node = db.get(RequirementNode, req_id)
+    if not node:
+        raise HTTPException(404, f"Requirement {req_id} not found")
+    entries = db.query(RequirementHistory).filter(
+        RequirementHistory.requirement_id == req_id
+    ).order_by(RequirementHistory.version.desc()).all()
+    return entries
+
+
+@router.get("/{req_id}/history/{version}", response_model=RequirementHistoryDetail)
+def get_history_version(req_id: str, version: int, db: Session = Depends(get_db)):
+    entry = db.query(RequirementHistory).filter(
+        RequirementHistory.requirement_id == req_id,
+        RequirementHistory.version == version,
+    ).first()
+    if not entry:
+        raise HTTPException(404, f"Version {version} not found for {req_id}")
+    return entry
+
+
+@router.post("/{req_id}/history/{version}/restore", response_model=RequirementResponse)
+def restore_version(req_id: str, version: int, db: Session = Depends(get_db)):
+    node = db.get(RequirementNode, req_id)
+    if not node:
+        raise HTTPException(404, f"Requirement {req_id} not found")
+
+    entry = db.query(RequirementHistory).filter(
+        RequirementHistory.requirement_id == req_id,
+        RequirementHistory.version == version,
+    ).first()
+    if not entry:
+        raise HTTPException(404, f"Version {version} not found for {req_id}")
+
+    # Restore fields from history snapshot
+    for field in _SNAPSHOT_FIELDS:
+        setattr(node, field, getattr(entry, field))
+
+    quality = validate_requirement(node, node.children)
+    node.traceable = quality.traceable
+
+    new_version = _next_version(db, req_id)
+    _create_history_entry(db, node, new_version, f"Restored from version {version}")
+
+    db.commit()
+    db.refresh(node)
+    return _to_response(node, include_children=True)

backend/app/routers/stats.py

@@ -0,0 +1,55 @@
+from fastapi import APIRouter, Depends
+from sqlalchemy import func
+from sqlalchemy.orm import Session
+
+from ..auth import verify_token
+from ..database import get_db
+from ..models import NodeType, RequirementNode
+from ..schemas import StatsResponse
+
+router = APIRouter(prefix="/api/stats", tags=["stats"], dependencies=[Depends(verify_token)])
+
+
+@router.get("", response_model=StatsResponse)
+def get_stats(project_id: int | None = None, db: Session = Depends(get_db)):
+    query = db.query(RequirementNode)
+    if project_id is not None:
+        query = query.filter(RequirementNode.project_id == project_id)
+
+    nodes = query.all()
+    total = len(nodes)
+
+    by_type = {}
+    by_status: dict[str, int] = {}
+    by_priority: dict[str, int] = {}
+    quality_passing = 0
+    leaves_with_tests = 0
+    total_leaves = 0
+
+    for n in nodes:
+        by_type[n.node_type.value] = by_type.get(n.node_type.value, 0) + 1
+        by_status[n.status.value] = by_status.get(n.status.value, 0) + 1
+        by_priority[n.priority.value] = by_priority.get(n.priority.value, 0) + 1
+
+        if n.traceable and n.measurable and n.consistent and n.single_purpose:
+            quality_passing += 1
+
+        if n.node_type == NodeType.leaf:
+            total_leaves += 1
+            if n.test_spec:
+                leaves_with_tests += 1
+
+    coverage = (leaves_with_tests / total_leaves * 100) if total_leaves > 0 else 0.0
+
+    return StatsResponse(
+        total_nodes=total,
+        pillars=by_type.get("pillar", 0),
+        requirements=by_type.get("requirement", 0),
+        sub_requirements=by_type.get("sub_requirement", 0),
+        leaves=by_type.get("leaf", 0),
+        by_status=by_status,
+        by_priority=by_priority,
+        quality_passing=quality_passing,
+        quality_failing=total - quality_passing,
+        coverage_percent=round(coverage, 1),
+    )