feat: add DesignPlan model, compute_score(), phase/plan fields to DesignState

agents/design_state.py

@@ -37,6 +37,59 @@ def _get_dim_contexts() -> dict[str, str]:
     }
 
 
+class DesignPlan(BaseModel):
+    """Structured plan presented to user for review/editing before generation."""
+    part_name: str = ""
+    description: str = ""
+    material: str = ""
+    dimensions: dict[str, float] = Field(default_factory=dict)
+    features: list[str] = Field(default_factory=list)
+    constraints: list[str] = Field(default_factory=list)
+    axis_recommendation: str = ""
+    machining_notes: list[str] = Field(default_factory=list)
+    confidence_score: float = 0.0
+
+    @classmethod
+    def from_state(cls, state: "DesignState", confidence_score: float) -> "DesignPlan":
+        """Create a plan snapshot from the current design state."""
+        return cls(
+            part_name=state.part_name,
+            description=state.description,
+            material=state.material,
+            dimensions=dict(state.dimensions),
+            features=list(state.features),
+            constraints=list(state.constraints),
+            axis_recommendation=state.axis_recommendation,
+            machining_notes=[],
+            confidence_score=confidence_score,
+        )
+
+    def render_approved(self) -> str:
+        """Render as an approved plan context block for LLM agents."""
+        lines = ["## APPROVED DESIGN PLAN (user-confirmed)"]
+        if self.part_name:
+            lines.append(f"Part: {self.part_name}")
+        if self.description:
+            lines.append(f"Description: {self.description}")
+        if self.material:
+            lines.append(f"Material: {self.material}")
+        if self.dimensions:
+            dims = ", ".join(f"{k}={v}mm" for k, v in self.dimensions.items())
+            lines.append(f"Dimensions: {dims}")
+        if self.features:
+            lines.append(f"Features: {'; '.join(self.features)}")
+        if self.constraints:
+            lines.append(f"Constraints: {'; '.join(self.constraints)}")
+        if self.axis_recommendation:
+            lines.append(f"Axis: {self.axis_recommendation}")
+        if self.machining_notes:
+            lines.append(f"Machining Notes: {'; '.join(self.machining_notes)}")
+        lines.append("")
+        lines.append("This plan has been reviewed and approved by the user.")
+        lines.append("Generate the model according to these specifications.")
+        return "\n".join(lines)
+
+
 class DesignState(BaseModel):
     """Structured state tracking design decisions across chat turns."""
     part_name: str = ""
@@ -47,6 +100,8 @@ class DesignState(BaseModel):
     constraints: list[str] = Field(default_factory=list)
     decisions: list[str] = Field(default_factory=list)
     axis_recommendation: str = ""
+    phase: str = "exploring"
+    plan: DesignPlan | None = None
 
     def render(self) -> str:
         """Render non-empty fields as a concise spec block for LLM context."""
@@ -188,6 +243,30 @@ class DesignState(BaseModel):
         return state
 
 
+def compute_score(state: DesignState) -> float:
+    """Compute completeness score for a design state using configured weights and caps."""
+    cfg = settings.planning
+    score = 0.0
+    if state.material:
+        score += cfg.weights.get("material", 3)
+    if state.part_name:
+        score += cfg.weights.get("part_name", 1)
+    if state.description:
+        score += cfg.weights.get("description", 1)
+    if state.axis_recommendation:
+        score += cfg.weights.get("axis_recommendation", 2)
+    dim_cap = cfg.caps.get("dimension", 4)
+    dim_count = min(len(state.dimensions), dim_cap)
+    score += dim_count * cfg.weights.get("dimension", 1)
+    feat_cap = cfg.caps.get("feature", 4)
+    feat_count = min(len(state.features), feat_cap)
+    score += feat_count * cfg.weights.get("feature", 1)
+    const_cap = cfg.caps.get("constraint", 2)
+    const_count = min(len(state.constraints), const_cap)
+    score += const_count * cfg.weights.get("constraint", 1)
+    return score
+
+
 def extract_decisions(
     agent_responses: list[dict],
     current_state: DesignState,

tests/test_design_state.py

@@ -1,6 +1,6 @@
 """Tests for agents/design_state.py — state tracking and decision extraction."""
 
-from agents.design_state import DesignState, extract_decisions
+from agents.design_state import DesignPlan, DesignState, compute_score, extract_decisions
 
 
 class TestDesignState:
@@ -88,3 +88,106 @@ class TestExtractDecisions:
         updated = extract_decisions(responses, existing)
         m6_count = sum(1 for f in updated.features if "M6" in f)
         assert m6_count == 1
+
+
+class TestDesignPlan:
+    def test_create_from_state(self):
+        state = DesignState(
+            part_name="bracket",
+            description="mounting bracket",
+            material="aluminum 6061",
+            dimensions={"width": 60.0, "height": 40.0, "depth": 20.0},
+            features=["4x M6 holes"],
+            constraints=["min wall 3mm"],
+            axis_recommendation="3-axis",
+            decisions=["use aluminum"],
+        )
+        plan = DesignPlan.from_state(state, confidence_score=9.0)
+        assert plan.part_name == "bracket"
+        assert plan.material == "aluminum 6061"
+        assert plan.dimensions == {"width": 60.0, "height": 40.0, "depth": 20.0}
+        assert plan.confidence_score == 9.0
+        assert plan.machining_notes == []
+
+    def test_plan_render(self):
+        plan = DesignPlan(
+            part_name="bracket",
+            description="test",
+            material="aluminum 6061",
+            dimensions={"width": 60.0},
+            features=["4x M6 holes"],
+            constraints=[],
+            axis_recommendation="3-axis",
+            machining_notes=["No undercuts"],
+            confidence_score=9.0,
+        )
+        rendered = plan.render_approved()
+        assert "APPROVED DESIGN PLAN" in rendered
+        assert "aluminum 6061" in rendered
+        assert "No undercuts" in rendered
+
+
+class TestComputeScore:
+    def test_empty_state_scores_zero(self):
+        assert compute_score(DesignState()) == 0.0
+
+    def test_material_scores_3(self):
+        state = DesignState(material="aluminum")
+        assert compute_score(state) == 3.0
+
+    def test_full_state_above_threshold(self):
+        state = DesignState(
+            part_name="bracket",
+            description="test bracket",
+            material="aluminum 6061",
+            dimensions={"width": 60.0, "height": 40.0, "depth": 20.0},
+            features=["4x M6 holes"],
+            constraints=["min wall 3mm"],
+            axis_recommendation="3-axis",
+        )
+        score = compute_score(state)
+        assert score >= 8.0
+
+    def test_dimension_cap_at_4(self):
+        state = DesignState(dimensions={
+            "width": 60, "height": 40, "depth": 20,
+            "length": 100, "diameter": 10, "radius": 5,
+        })
+        score = compute_score(state)
+        assert score == 4.0
+
+    def test_feature_cap_at_4(self):
+        state = DesignState(features=["a", "b", "c", "d", "e", "f"])
+        score = compute_score(state)
+        assert score == 4.0
+
+    def test_constraint_cap_at_2(self):
+        state = DesignState(constraints=["a", "b", "c", "d"])
+        score = compute_score(state)
+        assert score == 2.0
+
+
+class TestDesignStatePhase:
+    def test_default_phase_exploring(self):
+        state = DesignState()
+        assert state.phase == "exploring"
+        assert state.plan is None
+
+    def test_phase_serialization(self):
+        plan = DesignPlan(
+            part_name="b", description="", material="steel",
+            dimensions={}, features=[], constraints=[],
+            axis_recommendation="", machining_notes=[],
+            confidence_score=5.0,
+        )
+        state = DesignState(phase="planning", plan=plan)
+        d = state.model_dump()
+        assert d["phase"] == "planning"
+        assert d["plan"]["material"] == "steel"
+
+    def test_roundtrip_from_dict(self):
+        state = DesignState(phase="approved", material="brass")
+        d = state.model_dump()
+        restored = DesignState(**d)
+        assert restored.phase == "approved"
+        assert restored.material == "brass"