tst

Author: udithishanka

.gitignore

@@ -2,3 +2,4 @@
 mydatabase/
 temp/
 .DS_Store
+.aider*

aider-genius/README.md

@@ -248,3 +248,46 @@ This project maintains the same license as the original Aider project. See the [
 ---
 
 *Revolutionizing AI pair programming with intelligent agentic workflows for the future of software development.*
+# Calculator CLI
+
+This project provides a simple command-line interface (CLI) calculator that performs basic arithmetic operations.
+
+## Features
+
+- Addition
+- Subtraction
+- Multiplication
+- Division (with error handling for division by zero)
+
+## Usage
+
+To use the calculator, run the `cli_calculator.py` script with the desired operation and operands. For example:
+
+```bash
+python aider-genius/cli_calculator.py add 5 3
+```
+
+This will output:
+
+```
+The result of adding 5.0 and 3.0 is: 8.0
+```
+
+### Available Operations
+
+- `add`: Add two numbers.
+- `subtract`: Subtract the second number from the first.
+- `multiply`: Multiply two numbers.
+- `divide`: Divide the first number by the second (raises an error if the second number is zero).
+
+### Example Commands
+
+```bash
+python aider-genius/cli_calculator.py subtract 10 4
+python aider-genius/cli_calculator.py multiply 6 7
+python aider-genius/cli_calculator.py divide 8 2
+```
+
+## Error Handling
+
+The calculator handles division by zero by raising a `ValueError` with a clear error message.

aider-genius/aider/genius.jac

@@ -900,6 +900,76 @@ node ValidatorNode {
     # }
 }
 
+# User input node for task continuation
+node UserInputNode {
+    has status: str = "waiting";
+    has user_input: str = "";
+    has should_continue: bool = True;
+    
+    """Wait for user input and determine next action"""
+    def get_user_input(coder: Any) -> Tuple[str, bool] {
+        try {
+            coder.io.tool_output("\n" + "="*50);
+            coder.io.tool_output("Genius Agent - Task Completed!");
+            coder.io.tool_output("What would you like me to do next?");
+            coder.io.tool_output("Options:");
+            coder.io.tool_output("  - Describe a new task");
+            coder.io.tool_output("  - Type 'exit' or 'quit' to stop");
+            coder.io.tool_output("  - Type 'status' to see current repository state");
+            coder.io.tool_output("="*50);
+            
+            user_input = input("\nNext task > ").strip();
+            
+            if user_input.lower() in ['exit', 'quit', 'stop'] {
+                return ("", False);
+            } elif user_input.lower() == 'status' {
+                return ("status", True);
+            } elif user_input == '' {
+                return ("empty", True);  # Handle empty input separately
+            } else {
+                return (user_input, True);
+            }
+        } except (KeyboardInterrupt, EOFError) {
+            coder.io.tool_output("\nExiting Genius Agent...");
+            return ("", False);
+        } except Exception as e {
+            coder.io.tool_output(f"Error getting user input: {str(e)}");
+            return ("", False);
+        }
+    }
+    
+    """Show current repository status"""
+    def show_status(coder: Any) {
+        coder.io.tool_output("\nCurrent Repository Status:");
+        coder.io.tool_output("-" * 30);
+        
+        if coder.abs_fnames {
+            coder.io.tool_output("Files in current session:");
+            for fname in coder.abs_fnames {
+                coder.io.tool_output(f"  - {fname}");
+            }
+        } else {
+            coder.io.tool_output("No files in current session");
+        }
+        
+        if coder.repo {
+            try {
+                dirty_files = coder.repo.get_dirty_files();
+                if dirty_files {
+                    coder.io.tool_output("\nModified files:");
+                    for file in dirty_files {
+                        coder.io.tool_output(f"  - {file}");
+                    }
+                } else {
+                    coder.io.tool_output("\nNo uncommitted changes");
+                }
+            } except Exception as e {
+                coder.io.tool_output(f"Could not get git status: {e}");
+            }
+        }
+    }
+}
+
 # Terminal node for end of graph traversal
 node EndNode {}
 glob END = EndNode();
@@ -941,12 +1011,14 @@ walker GeniusAgent {
         planning_node = PlanningNode(task=self.task, status="pending", planning_model=self.planning_model);
         editor_node = EditorNode(file_path="", content="", changes=[], status="pending", editor_model=self.editor_model);
         validator_node = ValidatorNode(file_path="", issues=[], status="pending", validation_model=self.editor_model);
+        user_input_node = UserInputNode(status="waiting");
 
-        # Connect the workflow
+        # Connect the workflow with user input loop
         root ++> planning_node;
         planning_node ++> editor_node;
         editor_node ++> validator_node;
-        validator_node ++> END;
+        validator_node ++> user_input_node;  # Go to user input instead of END
+        # Note: UserInputNode will handle navigation based on user choice
 
         self.coder.io.tool_output(f"Genius Agent - Phase: Initialization | Action: Starting Genius Agent | Reasoning: Beginning autonomous development cycle for: {self.task}");
 
@@ -1196,9 +1268,67 @@ walker GeniusAgent {
             }
         }
 
+        # Generate report before moving to user input
+        self.generate_comprehensive_report();
+        
         visit [-->];
     }
 
+    # Handle user input and decide next action
+    can handle_user_input with UserInputNode entry {
+        here.status = "waiting";
+        
+        while True {
+            (user_input, should_continue) = here.get_user_input(self.coder);
+            
+            if not should_continue {
+                self.coder.io.tool_output("Genius Agent - Phase: Shutdown | Action: User requested exit | Reasoning: Gracefully shutting down");
+                # End the walker execution
+                return;
+            }
+            
+            if user_input == "status" {
+                here.show_status(self.coder);
+                continue;
+            }
+            
+            if user_input == "empty" {
+                self.coder.io.tool_output("Please provide a task description or type 'exit' to quit.");
+                continue;
+            }
+            
+            if user_input {
+                # Reset for new task
+                self.task = user_input;
+                self.task_explicitly_provided = True;
+                self.planning_complete = False;
+                self.last_error_context = None;
+                self.current_iteration = 0;
+                
+                self.coder.io.tool_output(f"Genius Agent - Phase: New Task | Action: Starting new task | Reasoning: User provided new task: {user_input}");
+                
+                # Create new nodes for the next cycle
+                planning_node = PlanningNode(task=self.task, status="pending", planning_model=self.planning_model);
+                editor_node = EditorNode(file_path="", content="", changes=[], status="pending", editor_model=self.editor_model);
+                validator_node = ValidatorNode(file_path="", issues=[], status="pending", validation_model=self.editor_model);
+                new_user_input_node = UserInputNode(status="waiting");
+                
+                # Connect the new workflow
+                here ++> planning_node;
+                planning_node ++> editor_node;
+                editor_node ++> validator_node;
+                validator_node ++> new_user_input_node;
+                
+                # Start the new cycle
+                visit [-->];
+                return;
+            } else {
+                here.show_status(self.coder);
+                self.coder.io.tool_output("Please provide a valid task or type 'exit' to quit.");
+            }
+        }
+    }
+
     # Handle reaching the end
     can finish with EndNode entry {
         success = len(self.completed_tasks) > 0;

aider-genius/calculator.py

@@ -89,3 +89,31 @@ def divide(self, a, b):
         if b == 0:
             raise ZeroDivisionError("Cannot divide by zero.")
         return a / b
+class Calculator:
+    """
+    A simple calculator class to perform basic arithmetic operations.
+
+    Methods:
+        add(a, b): Returns the sum of a and b.
+        subtract(a, b): Returns the difference of a and b.
+        multiply(a, b): Returns the product of a and b.
+        divide(a, b): Returns the division of a by b, raises an error if b is zero.
+    """
+
+    def add(self, a, b):
+        """Return the sum of a and b."""
+        return a + b
+
+    def subtract(self, a, b):
+        """Return the difference of a and b."""
+        return a - b
+
+    def multiply(self, a, b):
+        """Return the product of a and b."""
+        return a * b
+
+    def divide(self, a, b):
+        """Return the division of a by b. Raise ValueError if b is zero."""
+        if b == 0:
+            raise ValueError("Cannot divide by zero.")
+        return a / b

aider-genius/cli_calculator.py

@@ -28,3 +28,34 @@ def main():
 
 if __name__ == "__main__":
     main()
+import argparse
+from calculator import Calculator
+
+def main():
+    parser = argparse.ArgumentParser(description="Simple CLI Calculator")
+    parser.add_argument("operation", choices=["add", "subtract", "multiply", "divide"],
+                        help="The operation to perform: add, subtract, multiply, or divide")
+    parser.add_argument("a", type=float, help="The first operand")
+    parser.add_argument("b", type=float, help="The second operand")
+
+    args = parser.parse_args()
+
+    calculator = Calculator()
+
+    try:
+        if args.operation == "add":
+            result = calculator.add(args.a, args.b)
+        elif args.operation == "subtract":
+            result = calculator.subtract(args.a, args.b)
+        elif args.operation == "multiply":
+            result = calculator.multiply(args.a, args.b)
+        elif args.operation == "divide":
+            result = calculator.divide(args.a, args.b)
+
+        print(f"The result of {args.operation}ing {args.a} and {args.b} is: {result}")
+
+    except ValueError as e:
+        print(f"Error: {e}")
+
+if __name__ == "__main__":
+    main()

aider-genius/test_calculator.py

@@ -1,6 +1,38 @@
 import unittest
 from calculator import Calculator
 
+class TestCalculator(unittest.TestCase):
+
+    def setUp(self):
+        self.calculator = Calculator()
+
+    def test_add(self):
+        self.assertEqual(self.calculator.add(1, 2), 3)
+        self.assertEqual(self.calculator.add(-1, 1), 0)
+        self.assertEqual(self.calculator.add(-1, -1), -2)
+
+    def test_subtract(self):
+        self.assertEqual(self.calculator.subtract(10, 5), 5)
+        self.assertEqual(self.calculator.subtract(-1, 1), -2)
+        self.assertEqual(self.calculator.subtract(-1, -1), 0)
+
+    def test_multiply(self):
+        self.assertEqual(self.calculator.multiply(3, 7), 21)
+        self.assertEqual(self.calculator.multiply(-1, 1), -1)
+        self.assertEqual(self.calculator.multiply(-1, -1), 1)
+
+    def test_divide(self):
+        self.assertEqual(self.calculator.divide(10, 2), 5)
+        self.assertEqual(self.calculator.divide(-1, 1), -1)
+        self.assertEqual(self.calculator.divide(-1, -1), 1)
+        with self.assertRaises(ValueError):
+            self.calculator.divide(10, 0)
+
+if __name__ == '__main__':
+    unittest.main()
+import unittest
+from calculator import Calculator
+
 class TestCalculator(unittest.TestCase):
 
     def setUp(self):