cognify-code 0.2.1__tar.gz → 0.2.3__tar.gz

{cognify_code-0.2.1/src/cognify_code.egg-info → cognify_code-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognify-code
-Version: 0.2.1
+Version: 0.2.3
 Summary: Your local AI-powered code assistant. Review, generate, search, and refactor code with an intelligent AI agent—all running locally with complete privacy.
 Author-email: Ashok Kumar <akkssy@users.noreply.github.com>
 Maintainer-email: Ashok Kumar <akkssy@users.noreply.github.com>

{cognify_code-0.2.1 → cognify_code-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cognify-code"
-version = "0.2.1"
+version = "0.2.3"
 description = "Your local AI-powered code assistant. Review, generate, search, and refactor code with an intelligent AI agent—all running locally with complete privacy."
 readme = "README.md"
 license = {text = "MIT"}

{cognify_code-0.2.1 → cognify_code-0.2.3}/src/ai_code_assistant/__init__.py

@@ -5,7 +5,7 @@ Review, generate, search, and refactor code with an intelligent AI agent.
 All running locally with complete privacy using Ollama.
 """
 
-__version__ = "0.2.1"
+__version__ = "0.2.2"
 __author__ = "Ashok Kumar"
 
 from ai_code_assistant.config import Config, load_config

{cognify_code-0.2.1 → cognify_code-0.2.3}/src/ai_code_assistant/cli.py

@@ -156,41 +156,91 @@ def review(ctx, files: Tuple[Path, ...], review_type: str, output_format: str,
               type=click.Choice(["console", "markdown", "json"]))
 @click.option("--source", "-s", type=click.Path(exists=True, path_type=Path),
               help="Source file (for test mode)")
+@click.option("--stream/--no-stream", default=True, help="Stream output in real-time")
 @click.pass_context
 def generate(ctx, description: str, mode: str, language: str, name: Optional[str],
              params: Optional[str], output: Optional[Path], output_format: str,
-             source: Optional[Path]):
+             source: Optional[Path], stream: bool):
     """Generate code from natural language description."""
+    from rich.live import Live
+    from rich.markdown import Markdown
+    from rich.panel import Panel
+    
     config, llm = get_components(ctx.obj.get("config_path"))
     generator = CodeGenerator(config, llm)
     formatter = get_formatter(output_format, config.output.use_colors)
 
     console.print(f"\n[bold]Generating {mode} in {language}...[/bold]\n")
 
-    with console.status("[bold green]Generating code..."):
-        if mode == "function":
-            result = generator.generate_function(
-                description=description, name=name or "generated_function",
-                language=language, parameters=params or "",
-            )
-        elif mode == "class":
-            result = generator.generate_class(
-                description=description, name=name or "GeneratedClass", language=language,
-            )
-        elif mode == "script":
-            result = generator.generate_script(
-                description=description, requirements=[description], language=language,
-            )
-        elif mode == "test":
-            if not source:
-                console.print("[red]Error:[/red] --source required for test mode")
-                sys.exit(1)
-            source_code = source.read_text()
-            result = generator.generate_tests(source_code=source_code, language=language)
-        else:
-            result = generator.generate(description=description, language=language)
+    # Handle test mode source requirement
+    source_code = ""
+    if mode == "test":
+        if not source:
+            console.print("[red]Error:[/red] --source required for test mode")
+            sys.exit(1)
+        source_code = source.read_text()
+
+    if stream:
+        # Streaming mode - show output as it generates
+        full_response = ""
+        final_code = ""
+        
+        console.print("[dim]Streaming response...[/dim]\n")
+        
+        for chunk, is_complete in generator.generate_stream(
+            description=description,
+            mode=mode,
+            language=language,
+            name=name or "",
+            parameters=params or "",
+            source_code=source_code,
+        ):
+            if is_complete:
+                final_code = chunk
+            else:
+                console.print(chunk, end="", highlight=False)
+                full_response += chunk
+        
+        console.print("\n")
+        
+        # Create result for formatting
+        from ai_code_assistant.generator import GenerationResult
+        result = GenerationResult(
+            code=final_code,
+            language=language,
+            mode=mode,
+            description=description,
+            raw_response=full_response,
+        )
+        
+        # Show extracted code in a panel
+        console.print(Panel(
+            final_code,
+            title=f"[bold green]Generated {mode.title()}[/bold green]",
+            border_style="green",
+        ))
+    else:
+        # Non-streaming mode (original behavior)
+        with console.status("[bold green]Generating code..."):
+            if mode == "function":
+                result = generator.generate_function(
+                    description=description, name=name or "generated_function",
+                    language=language, parameters=params or "",
+                )
+            elif mode == "class":
+                result = generator.generate_class(
+                    description=description, name=name or "GeneratedClass", language=language,
+                )
+            elif mode == "script":
+                result = generator.generate_script(
+                    description=description, requirements=[description], language=language,
+                )
+            elif mode == "test":
+                result = generator.generate_tests(source_code=source_code, language=language)
+            else:
+                result = generator.generate(description=description, language=language)
 
-    formatted = formatter.format_generation(result)
+        formatted = formatter.format_generation(result)
 
     if output and result.success:
         output.parent.mkdir(parents=True, exist_ok=True)
@@ -222,7 +272,7 @@ def chat(ctx, context: Tuple[Path, ...], stream: bool):
         "  /clear        - Clear conversation history\n"
         "  /context      - Show loaded context files\n"
         "  /export       - Export conversation to markdown\n"
-        "  /quit         - Exit chat\n",
+        "  /quit or exit - Exit chat\n",
         title="Interactive Mode",
     ))
 
@@ -236,6 +286,11 @@ def chat(ctx, context: Tuple[Path, ...], stream: bool):
         if not user_input:
             continue
 
+        # Handle exit commands without slash
+        if user_input.lower() in ("exit", "quit", "bye", "q"):
+            console.print("[dim]Goodbye![/dim]")
+            break
+
         # Handle commands
         if user_input.startswith("/"):
             cmd_parts = user_input[1:].split(maxsplit=1)

{cognify_code-0.2.1 → cognify_code-0.2.3}/src/ai_code_assistant/generator/code_gen.py

@@ -3,7 +3,7 @@
 import re
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import List, Literal, Optional
+from typing import Iterator, List, Literal, Optional, Tuple
 
 from ai_code_assistant.config import Config
 from ai_code_assistant.llm import LLMManager
@@ -214,6 +214,160 @@ class CodeGenerator:
                 error=str(e),
             )
 
+
+    def generate_stream(
+        self,
+        description: str,
+        mode: str = "generic",
+        language: str = "python",
+        name: str = "",
+        parameters: str = "",
+        source_code: str = "",
+    ) -> Iterator[Tuple[str, bool]]:
+        """
+        Stream code generation with real-time output.
+        
+        Yields tuples of (chunk, is_complete).
+        The final yield will have is_complete=True and contain the extracted code.
+        """
+        # Build the prompt based on mode
+        if mode == "function":
+            prompt_template = GENERATION_PROMPTS["function"]
+            formatted = prompt_template.format(
+                language=language,
+                description=description,
+                name=name or "generated_function",
+                parameters=parameters or "None specified",
+                return_type="appropriate type",
+                include_type_hints=self.config.generation.include_type_hints,
+                include_docstrings=self.config.generation.include_docstrings,
+            )
+        elif mode == "class":
+            prompt_template = GENERATION_PROMPTS["class"]
+            formatted = prompt_template.format(
+                language=language,
+                description=description,
+                name=name or "GeneratedClass",
+                attributes="None specified",
+                methods="None specified",
+                include_type_hints=self.config.generation.include_type_hints,
+                include_docstrings=self.config.generation.include_docstrings,
+            )
+        elif mode == "script":
+            prompt_template = GENERATION_PROMPTS["script"]
+            formatted = prompt_template.format(
+                language=language,
+                description=description,
+                requirements=f"- {description}",
+                include_type_hints=self.config.generation.include_type_hints,
+                include_docstrings=self.config.generation.include_docstrings,
+            )
+        elif mode == "test":
+            prompt_template = GENERATION_PROMPTS["test"]
+            formatted = prompt_template.format(
+                language=language,
+                source_code=source_code,
+                test_framework="pytest",
+            )
+        else:  # generic
+            prompt_template = GENERATION_PROMPTS["generic"]
+            formatted = prompt_template.format(
+                language=language,
+                description=description,
+                include_type_hints=self.config.generation.include_type_hints,
+                include_docstrings=self.config.generation.include_docstrings,
+            )
+
+        # Stream the response
+        full_response = ""
+        try:
+            for chunk in self.llm.stream(formatted):
+                full_response += chunk
+                yield (chunk, False)
+            
+            # Extract code and yield final result
+            code = self._extract_code(full_response, language)
+            yield (code, True)
+        except Exception as e:
+            yield (f"Error: {str(e)}", True)
+
+
+    def generate_stream(
+        self,
+        description: str,
+        mode: str = "generic",
+        language: str = "python",
+        name: str = "",
+        parameters: str = "",
+        source_code: str = "",
+    ) -> Iterator[Tuple[str, bool]]:
+        """
+        Stream code generation with real-time output.
+        
+        Yields tuples of (chunk, is_complete).
+        The final yield will have is_complete=True and contain the extracted code.
+        """
+        # Build the prompt based on mode
+        if mode == "function":
+            prompt_template = GENERATION_PROMPTS["function"]
+            formatted = prompt_template.format(
+                language=language,
+                description=description,
+                name=name or "generated_function",
+                parameters=parameters or "None specified",
+                return_type="appropriate type",
+                include_type_hints=self.config.generation.include_type_hints,
+                include_docstrings=self.config.generation.include_docstrings,
+            )
+        elif mode == "class":
+            prompt_template = GENERATION_PROMPTS["class"]
+            formatted = prompt_template.format(
+                language=language,
+                description=description,
+                name=name or "GeneratedClass",
+                attributes="None specified",
+                methods="None specified",
+                include_type_hints=self.config.generation.include_type_hints,
+                include_docstrings=self.config.generation.include_docstrings,
+            )
+        elif mode == "script":
+            prompt_template = GENERATION_PROMPTS["script"]
+            formatted = prompt_template.format(
+                language=language,
+                description=description,
+                requirements=f"- {description}",
+                include_type_hints=self.config.generation.include_type_hints,
+                include_docstrings=self.config.generation.include_docstrings,
+            )
+        elif mode == "test":
+            prompt_template = GENERATION_PROMPTS["test"]
+            formatted = prompt_template.format(
+                language=language,
+                source_code=source_code,
+                test_framework="pytest",
+            )
+        else:  # generic
+            prompt_template = GENERATION_PROMPTS["generic"]
+            formatted = prompt_template.format(
+                language=language,
+                description=description,
+                include_type_hints=self.config.generation.include_type_hints,
+                include_docstrings=self.config.generation.include_docstrings,
+            )
+
+        # Stream the response
+        full_response = ""
+        try:
+            for chunk in self.llm.stream(formatted):
+                full_response += chunk
+                yield (chunk, False)
+            
+            # Extract code and yield final result
+            code = self._extract_code(full_response, language)
+            yield (code, True)
+        except Exception as e:
+            yield (f"Error: {str(e)}", True)
+
     def _extract_code(self, response: str, language: str) -> str:
         """Extract code block from LLM response."""
         # Try to find language-specific code block

{cognify_code-0.2.1 → cognify_code-0.2.3/src/cognify_code.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognify-code
-Version: 0.2.1
+Version: 0.2.3
 Summary: Your local AI-powered code assistant. Review, generate, search, and refactor code with an intelligent AI agent—all running locally with complete privacy.
 Author-email: Ashok Kumar <akkssy@users.noreply.github.com>
 Maintainer-email: Ashok Kumar <akkssy@users.noreply.github.com>