test fixes

Author: bboynton97

agentstack/cli/init.py

@@ -105,6 +105,13 @@ def init_project(
     if use_wizard:
         log.debug("Initializing new project with wizard.")
         template_data = run_wizard(slug_name)
+    elif template == "empty":
+        log.debug("Initializing new project with empty template.")
+        template_data = TemplateConfig(
+            name=slug_name,
+            description="",
+            framework=framework or frameworks.DEFAULT_FRAMEWORK,
+        )
     elif template:
         log.debug(f"Initializing new project with template: {template}")
         template_data = TemplateConfig.from_user_input(template)

agentstack/frameworks/__init__.py

@@ -73,12 +73,6 @@ def validate_project(self) -> None:
         """
         ...
 
-    def parse_llm(self, llm: str) -> tuple[str, str]:
-        """
-        Parse a language model string into a provider and model.
-        """
-        ...
-
     def add_agent(self, agent: 'AgentConfig', position: Optional[InsertionPoint] = None) -> None:
         """
         Add an agent to the user's project.
@@ -491,55 +485,3 @@ def get_graph() -> list[graph.Edge]:
     """
     module = get_framework_module(get_framework())
     return module.get_graph()
-
-
-def create_tool(tool_name: str):
-    """
-    Create a new custom tool in the user's project.
-    The tool will be created with a basic structure and configuration.
-    """
-    module = get_framework_module(get_framework())
-    entrypoint = module.get_entrypoint()
-
-    # Check if tool already exists
-    user_tools_dir = conf.PATH / 'src/tools'
-    tool_path = user_tools_dir / tool_name
-    if tool_path.exists():
-        raise ValidationError(f"Tool '{tool_name}' already exists.")
-
-    # Create tool directory
-    tool_path.mkdir(parents=True, exist_ok=False)
-
-    # Create __init__.py with basic function template
-    init_file = tool_path / '__init__.py'
-    init_content = f'''def {tool_name}_tool(input_str: str) -> str:
-        """
-        Define your tool's functionality here.
-
-        Args:
-            input_str: Input string to process
-
-        Returns:
-            str: Result of the tool's operation
-        """ 
-        # Add your tool's logic here
-        return f"Processed: {{input_str}}"
-    '''
-    init_file.write_text(init_content)
-
-    tool_config = ToolConfig(
-        name=tool_name,
-        category="custom",
-        tools=[tool_name, ],
-    )
-    tool_config.write_to_file(tool_path / 'config.json')
-
-    # Update the project's configuration with the new tool
-    agentstack_config = conf.ConfigFile()
-    agentstack_config.tools.append(tool_config.name)
-    agentstack_config.write()
-
-    with entrypoint:
-        entrypoint.add_import(f'.tools.{tool_name}', f'{tool_name}_tool')
-
-    return module.create_tool(tool_name)

agentstack/generation/tool_generation.py

@@ -68,23 +68,31 @@ def create_tool(tool_name: str, agents: Optional[list[str]] = []):
 
     # Create __init__.py with basic function template
     init_file = tool_path / '__init__.py'
-    init_content = f'''def {tool_name}():
+    init_content = f'''
+    
+def {tool_name}_tool(value: str) -> str:
     """
     Define your tool's functionality here.
-    """
-    pass
+
+    Args:
+        value: Input to process (should be typed in function definition)
+
+    Returns:
+        str: Result of the tool's operation
+    """ 
+    # Add your tool's logic here
+    return value
 '''
     init_file.write_text(init_content)
 
     tool_config = ToolConfig(
         name=tool_name,
         category="custom",
-        tools=[tool_name, ],
+        tools=[f'{tool_name}_tool', ],
     )
     tool_config.write_to_file(tool_path / 'config.json')
 
     # Edit the framework entrypoint file to include the tool in the agent definition
-    tool = ToolConfig.from_tool_name(tool_name)
     if not agents:  # If no agents are specified, add the tool to all agents
         agents = frameworks.get_agent_method_names()
     for agent_name in agents:

tests/test_cli_tools.py

@@ -13,6 +13,7 @@
 
 
 BASE_PATH = Path(__file__).parent
+TEMPLATE_NAME = "empty"
 
 class CLIToolsTest(unittest.TestCase):
     def setUp(self):
@@ -28,7 +29,7 @@ def tearDown(self):
     @unittest.skip("Dependency resolution issue")
     def test_add_tool(self, tool_name):
         """Test the adding every tool to a project."""
-        result = run_cli('init', f"{tool_name}_project")
+        result = run_cli('init', f"{tool_name}_project", "--template", TEMPLATE_NAME)
         self.assertEqual(result.returncode, 0)
         os.chdir(self.project_dir / f"{tool_name}_project")
         result = run_cli('generate', 'agent', 'test_agent', '--llm', 'opeenai/gpt-4o')
@@ -67,7 +68,7 @@ def test_get_validated_input(self):
     def test_create_tool_basic(self):
         """Test creating a new custom tool via CLI"""
         # Initialize a project first
-        result = run_cli('init', "test_project")
+        result = run_cli('init', "test_project", "--template", TEMPLATE_NAME)
         self.assertEqual(result.returncode, 0)
         os.chdir(self.project_dir / "test_project")
 
@@ -76,61 +77,56 @@ def test_create_tool_basic(self):
         self.assertEqual(result.returncode, 0)
 
         # Create a new tool
-        result = run_cli('tools', 'create', 'test_tool')
+        result = run_cli('tools', 'new', 'test_tool')
         self.assertEqual(result.returncode, 0)
 
         # Verify tool directory and files were created
-        tool_path = Path('src/tools/test_tool')
+        tool_path = self.project_dir / "test_project" / 'src/tools/test_tool'
         self.assertTrue(tool_path.exists())
         self.assertTrue((tool_path / '__init__.py').exists())
         self.assertTrue((tool_path / 'config.json').exists())
 
     def test_create_tool_with_agents(self):
         """Test creating a new custom tool with specific agents via CLI"""
         # Initialize project and create multiple agents
-        result = run_cli('init', "test_project")
+        result = run_cli('init', "test_project", "--template", TEMPLATE_NAME)
         self.assertEqual(result.returncode, 0)
         os.chdir(self.project_dir / "test_project")
 
         run_cli('generate', 'agent', 'agent1', '--llm', 'openai/gpt-4')
         run_cli('generate', 'agent', 'agent2', '--llm', 'openai/gpt-4')
 
         # Create tool with specific agent
-        result = run_cli('tools', 'create', 'test_tool', '--agents', 'agent1')
+        result = run_cli('tools', 'new', 'test_tool', '--agents', 'agent1')
         self.assertEqual(result.returncode, 0)
 
         # Verify tool was created
-        tool_path = Path('src/tools/test_tool')
+        tool_path = self.project_dir / "test_project" / 'src/tools/test_tool'
         self.assertTrue(tool_path.exists())
 
-        # Verify tool was added to correct agent
-        with open('agentstack.json') as f:
-            config = f.read()
-            self.assertIn('test_tool', config)
-
     def test_create_tool_existing(self):
         """Test creating a tool that already exists"""
         # Initialize project
-        result = run_cli('init', "test_project")
+        result = run_cli('init', "test_project", "--template", TEMPLATE_NAME)
         self.assertEqual(result.returncode, 0)
         os.chdir(self.project_dir / "test_project")
 
         # Create agent
         run_cli('generate', 'agent', 'test_agent', '--llm', 'openai/gpt-4')
 
         # Create tool first time
-        result = run_cli('tools', 'create', 'test_tool')
+        result = run_cli('tools', 'new', 'test_tool')
         self.assertEqual(result.returncode, 0)
 
         # Try to create same tool again
-        result = run_cli('tools', 'create', 'test_tool')
+        result = run_cli('tools', 'new', 'test_tool')
         self.assertNotEqual(result.returncode, 0)  # Should fail
         self.assertIn("already exists", result.stderr)
 
     def test_create_tool_invalid_name(self):
         """Test creating a tool with invalid name formats"""
         # Initialize project
-        result = run_cli('init', "test_project")
+        result = run_cli('init', "test_project", "--template", TEMPLATE_NAME)
         self.assertEqual(result.returncode, 0)
         os.chdir(self.project_dir / "test_project")
 
@@ -148,5 +144,4 @@ def test_create_tool_no_project(self):
         """Test creating a tool outside a project directory"""
         # Try to create tool without initializing project
         result = run_cli('tools', 'new', 'test_tool')
-        self.assertNotEqual(result.returncode, 0)
-        self.assertIn("Could not find agentstack.json", result.stderr)
+        self.assertNotEqual(result.returncode, 0)

tests/test_generation_tool.py

@@ -79,8 +79,6 @@ def test_create_tool_basic(self):
         # Execute
         create_tool(
             tool_name=tool_name,
-            tool_path=tool_path,
-            user_tools_dir=self.tools_dir
         )
 
         # Assert directory was created
@@ -91,7 +89,7 @@ def test_create_tool_basic(self):
         init_file = tool_path / "__init__.py"
         self.assertTrue(init_file.exists())
         init_content = init_file.read_text()
-        self.assertIn(f"def {tool_name}():", init_content)
+        self.assertIn(f"def {tool_name}_tool", init_content)
         self.assertIn('"""', init_content)  # Check docstring exists
 
         # Assert config.json was created with correct content
@@ -100,7 +98,7 @@ def test_create_tool_basic(self):
         config = json.loads(config_file.read_text())
         self.assertEqual(config["name"], tool_name)
         self.assertEqual(config["category"], "custom")
-        self.assertEqual(config["tools"], [tool_name])
+        self.assertEqual(config["tools"], [f"{tool_name}_tool"])
 
     def test_create_tool_specific_agents(self):
         """Test tool creation with specific agents"""
@@ -109,8 +107,6 @@ def test_create_tool_specific_agents(self):
 
         create_tool(
             tool_name=tool_name,
-            tool_path=tool_path,
-            user_tools_dir=self.tools_dir,
         )
 
         # Assert directory and files were created
@@ -124,30 +120,25 @@ def test_create_tool_specific_agents(self):
 
     def test_create_tool_directory_exists(self):
         """Test tool creation fails when directory already exists"""
-        tool_name = "test_tool"
+        tool_name = "test_tool_directory_exists"
         tool_path = self.tools_dir / tool_name
 
         # Create the directory first
         tool_path.mkdir(parents=True)
 
         # Assert raises error when trying to create tool in existing directory
-        with self.assertRaises(FileExistsError):
+        with self.assertRaises(Exception):
             create_tool(
                 tool_name=tool_name,
-                tool_path=tool_path,
-                user_tools_dir=self.tools_dir
             )
 
     @patch('agentstack.generation.tool_generation.log.success')
     def test_create_tool_success_logging(self, mock_log_success):
         """Test success logging message"""
         tool_name = "test_tool"
-        tool_path = self.tools_dir / tool_name
 
         create_tool(
             tool_name=tool_name,
-            tool_path=tool_path,
-            user_tools_dir=self.tools_dir
         )
 
         mock_log_success.assert_called_once()