model fixation for commands and subagents

Reviewed-on: #14

.claude/agents/next-issue.md

@@ -2,6 +2,7 @@
 name: next-issue
 description: Wählt das nächste zu bearbeitende Gitea-Issue und gibt nur die Kerndaten zurück.
 tools: mcp__gitea__list_issues, mcp__gitea__issue_read
+model: haiku
 ---
 Finde das nächste offene Issue im Repo <owner>/<repo> mit Label `ai-ready`
 und NICHT mit Label `ai-wip` oder `ai-blocked`.

.claude/commands/fix-issue.md

@@ -6,6 +6,7 @@ allowed-tools: >
   mcp__gitea__issue_read, mcp__gitea__issue_write,
   mcp__gitea__label_read,
   mcp__gitea__pull_request_write
+model: opus
 ---
 Bearbeite Gitea-Issue #$1 im aktuellen Repo. Schritt für Schritt:
 

.gitattributes

@@ -0,0 +1,12 @@
+# Normalize line endings independent of core.autocrlf.
+* text=auto
+
+# Maven wrapper: POSIX shell script must stay LF, even on Windows checkouts.
+mvnw text eol=lf
+*.sh text eol=lf
+
+# Windows batch wrapper needs CRLF.
+mvnw.cmd text eol=crlf
+
+# Binaries: never convert.
+*.jar binary

src/main/java/com/example/LoopTestApplication.java

@@ -1,25 +1,16 @@
 package com.example;
 
-import com.example.util.AddFunction;
 import com.example.util.CalcFunction;
-import com.example.util.DivideFunction;
-import com.example.util.MultiplyFunction;
-import com.example.util.PowerFunction;
-import com.example.util.SubtractFunction;
+import com.example.util.CalcFunctionFactory;
+import com.example.util.CalcOperation;
 
 public class LoopTestApplication {
 
     static void main() {
         System.out.println("============== Calculator =============");
-        CalcFunction add = new AddFunction();
-        System.out.println("ADDITION: " + add.calc(2, 5, 6));
-        CalcFunction subtract = new SubtractFunction();
-        System.out.println("SUBTRACTION: " + subtract.calc(2, 5, 6));
-        CalcFunction multiply = new MultiplyFunction();
-        System.out.println("MULTIPLICATION: " + multiply.calc(2, 5, 6));
-        CalcFunction divide = new DivideFunction();
-        System.out.println("DIVISION: " + divide.calc(2, 5, 6));
-        CalcFunction power = new PowerFunction();
-        System.out.println("POWER: " + power.calc(2, 5, 6));
+        for (CalcOperation operation : CalcOperation.values()) {
+            CalcFunction function = CalcFunctionFactory.create(operation);
+            System.out.println(operation + ": " + function.calc(2, 5, 6));
+        }
     }
 }

src/main/java/com/example/util/CalcFunctionFactory.java

@@ -0,0 +1,20 @@
+package com.example.util;
+
+public final class CalcFunctionFactory {
+
+    private CalcFunctionFactory() {
+    }
+
+    public static CalcFunction create(CalcOperation operation) {
+        if (operation == null) {
+            throw new IllegalArgumentException("Operation must not be null");
+        }
+        return switch (operation) {
+            case ADD -> new AddFunction();
+            case SUBTRACT -> new SubtractFunction();
+            case MULTIPLY -> new MultiplyFunction();
+            case DIVIDE -> new DivideFunction();
+            case POWER -> new PowerFunction();
+        };
+    }
+}

src/main/java/com/example/util/CalcOperation.java

@@ -0,0 +1,10 @@
+package com.example.util;
+
+public enum CalcOperation {
+
+    ADD,
+    SUBTRACT,
+    MULTIPLY,
+    DIVIDE,
+    POWER
+}

src/test/java/com/example/util/CalcFunctionFactoryTest.java

@@ -0,0 +1,53 @@
+package com.example.util;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+class CalcFunctionFactoryTest {
+
+    @Test
+    void createsAddFunction() {
+        assertInstanceOf(AddFunction.class, CalcFunctionFactory.create(CalcOperation.ADD));
+    }
+
+    @Test
+    void createsSubtractFunction() {
+        assertInstanceOf(SubtractFunction.class, CalcFunctionFactory.create(CalcOperation.SUBTRACT));
+    }
+
+    @Test
+    void createsMultiplyFunction() {
+        assertInstanceOf(MultiplyFunction.class, CalcFunctionFactory.create(CalcOperation.MULTIPLY));
+    }
+
+    @Test
+    void createsDivideFunction() {
+        assertInstanceOf(DivideFunction.class, CalcFunctionFactory.create(CalcOperation.DIVIDE));
+    }
+
+    @Test
+    void createsPowerFunction() {
+        assertInstanceOf(PowerFunction.class, CalcFunctionFactory.create(CalcOperation.POWER));
+    }
+
+    @Test
+    void createsFunctionForEveryOperation() {
+        for (CalcOperation operation : CalcOperation.values()) {
+            assertNotNull(CalcFunctionFactory.create(operation), "No function for " + operation);
+        }
+    }
+
+    @Test
+    void createdFunctionCalculates() {
+        assertEquals(13.0, CalcFunctionFactory.create(CalcOperation.ADD).calc(2.0, 5.0, 6.0));
+    }
+
+    @Test
+    void rejectsNullOperation() {
+        assertThrows(IllegalArgumentException.class, () -> CalcFunctionFactory.create(null));
+    }
+}