janito 0.6.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

janito/config.py

@@ -1,102 +1,100 @@
-from typing import Optional, List
-import os
-from pathlib import Path
-
-class ConfigManager:
-    _instance = None
-
-    def __init__(self):
-        self.debug = False
-        self.verbose = False
-        self.debug_line = None
-        self.test_cmd = os.getenv('JANITO_TEST_CMD')
-        self.workspace_dir = Path.cwd()
-        self.raw = False
-        self.include: List[Path] = []
-        self.recursive: List[Path] = []
-        self.auto_apply: bool = False
-        self.tui: bool = False
-        self.skipwork: bool = False
-
-    @classmethod
-    def get_instance(cls) -> "ConfigManager":
-        if cls._instance is None:
-            cls._instance = cls()
-        return cls._instance
-
-    def set_debug(self, enabled: bool) -> None:
-        self.debug = enabled
-
-    def set_verbose(self, enabled: bool) -> None:
-        self.verbose = enabled
-
-    def set_debug_line(self, line: Optional[int]) -> None:
-        self.debug_line = line
-
-    def should_debug_line(self, line: int) -> bool:
-        """Return True if we should show debug for this line number"""
-        return self.debug and (self.debug_line is None or self.debug_line == line)
-
-    def set_test_cmd(self, cmd: Optional[str]) -> None:
-        """Set the test command, overriding environment variable"""
-        self.test_cmd = cmd if cmd is not None else os.getenv('JANITO_TEST_CMD')
-
-    def set_workspace_dir(self, path: Optional[Path]) -> None:
-        """Set the workspace directory"""
-        self.workspace_dir = path if path is not None else Path.cwd()
-
-    def set_raw(self, enabled: bool) -> None:
-        """Set raw output mode"""
-        self.raw = enabled
-
-    def set_include(self, paths: Optional[List[Path]]) -> None:
-        """
-        Set additional paths to include.
-
-        Args:
-            paths: List of paths to include
-
-        Raises:
-            ValueError: If duplicate paths are provided
-        """
-        if paths is None:
-            self.include = []
-            return
-
-        # Convert paths to absolute and resolve symlinks
-        resolved_paths = [p.absolute().resolve() for p in paths]
-
-        # Check for duplicates
-        seen_paths = set()
-        unique_paths = []
-
-        for path in resolved_paths:
-            if path in seen_paths:
-                raise ValueError(f"Duplicate path provided: {path}")
-            seen_paths.add(path)
-            unique_paths.append(path)
-
-        self.include = unique_paths
-
-    def set_auto_apply(self, enabled: bool) -> None:
-        """Set auto apply mode"""
-        self.auto_apply = enabled
-
-    def set_tui(self, enabled: bool) -> None:
-        """Set TUI mode"""
-        self.tui = enabled
-
-    def set_recursive(self, paths: Optional[List[Path]]) -> None:
-        """Set paths to scan recursively
-
-        Args:
-            paths: List of directory paths to scan recursively, or None to disable recursive scanning
-        """
-        self.recursive = paths
-
-    def set_skipwork(self, enabled: bool) -> None:
-        """Set skipwork flag to skip scanning workspace_dir"""
-        self.skipwork = enabled
-
-# Create a singleton instance
+from typing import Optional
+import os
+from pathlib import Path
+
+class ConfigManager:
+    """Singleton configuration manager for the application."""
+    
+    _instance = None
+
+    def __init__(self):
+        """Initialize configuration with default values."""
+        self.debug = False
+        self.verbose = False
+        self.test_cmd = os.getenv('JANITO_TEST_CMD')
+        self.workspace_dir = Path.cwd()
+        self.raw = False
+        self.auto_apply: bool = False
+        self.skip_work: bool = False
+
+    @classmethod
+    def get_instance(cls) -> "ConfigManager":
+        """Return the singleton instance of ConfigManager.
+        
+        Returns:
+            ConfigManager: The singleton instance
+        """
+        if cls._instance is None:
+            cls._instance = cls()
+        return cls._instance
+
+    def set_debug(self, enabled: bool) -> None:
+        """Set debug mode.
+        
+        Args:
+            enabled: True to enable debug mode, False to disable
+        """
+        self.debug = enabled
+
+    def set_verbose(self, enabled: bool) -> None:
+        """Set verbose output mode.
+        
+        Args:
+            enabled: True to enable verbose output, False to disable
+        """
+        self.verbose = enabled
+
+    def set_debug_line(self, line: Optional[int]) -> None:
+        """Set specific line number for debug output.
+        
+        Args:
+            line: Line number to debug, or None for all lines
+        """
+        self.debug_line = line
+
+    def should_debug_line(self, line: int) -> bool:
+        """Return True if we should show debug for this line number"""
+        return self.debug and (self.debug_line is None or self.debug_line == line)
+
+    def set_test_cmd(self, cmd: Optional[str]) -> None:
+        """Set the test command, overriding environment variable"""
+        self.test_cmd = cmd if cmd is not None else os.getenv('JANITO_TEST_CMD')
+
+    def set_workspace_dir(self, path: Optional[Path]) -> None:
+        """Set the workspace directory"""
+        self.workspace_dir = path if path is not None else Path.cwd()
+
+    def set_raw(self, enabled: bool) -> None:
+        """Set raw output mode.
+        
+        Args:
+            enabled: True to enable raw output mode, False to disable
+        """
+        self.raw = enabled
+
+    def set_auto_apply(self, enabled: bool) -> None:
+        """Set auto apply mode for changes.
+        
+        Args:
+            enabled: True to enable auto apply mode, False to disable
+        """
+        self.auto_apply = enabled
+
+    def set_tui(self, enabled: bool) -> None:
+        """Set Text User Interface mode.
+        
+        Args:
+            enabled: True to enable TUI mode, False to disable
+        """
+        self.tui = enabled
+
+    def set_skip_work(self, enabled: bool) -> None:
+        """Set whether to skip scanning the workspace directory.
+        
+        Args:
+            enabled: True to skip workspace directory, False to include it
+        """
+        self.skip_work = enabled
+
+# Create a singleton instance
 config = ConfigManager.get_instance()

janito/data/change_prompt.txt

@@ -0,0 +1,81 @@
+Provide the instructions for the change request:
+{request}
+
+This is the workset:
+
+{workset}
+
+Before providing the actual changes, please provide an action plan in markdown format. The action plan should include the following sections:
+
+Execution Planning:
+1. Brief introduction refering the files and sections that will be affected.
+
+Implementation:
+- Both the original code and the modified code should be provided in plain text format with:
+    - original indentation as found in the original file
+    - original or modified indentation as might be required for the changes (eg, adding a try block will shift the indentation of the code inside the block)
+- When the user asks for edits to their code, the assistant will provide one or edit blocks, a block can contain multiple changes to the same file.
+- When new imports are required, they should be placed at the top of the existing files, even if that requires an extra edit block.
+- Merge edit blocks that would affect the same function/method into a single edit block
+
+Edit <path/to/file> "<reason for the change>"
+<<<< original
+{{ Assistant writes original lines found in the workset }}
+>>>> modified
+{{ Assistant writes the lines to replace the original }}
+==== # marks end of file edit block
+
+# For removing large pieces of code, use the "clean" operation
+Clean <path/to/file> "{{ Assistant writes reason }}"
+<<<< starting
+{{ Assistant writes the first lines to match where cleaning starts }}
+>>>> ending
+{{ Assistant writes the last lines to match where cleaning ends }}
+# The cleaning operation removes all content between and including the starting and ending markers
+# Be careful to provide minimal but sufficient lines to identify the correct content
+====
+
+Create <path/to/file> "{{ Assistant writes reason }}"
+>>>> modified
+{{ Assistant writes the full content of the file }}
+====
+
+Delete <path/to/file> "{{ Assistant writes reason }}"
+==== # for deletes there is no need for markers, just the end marker
+
+Avoid common pitfalls:
+
+- Adding a try block without the entire affected content
+Edit file
+<<<< original
+    def _apply_and_collect_change(self, edit: CodeChange) -> AppliedBlock:
+        """Apply a single edit and collect its change information."""
+        do_thing()
+
+>>>> modified
+    def _apply_and_collect_change(self, edit: CodeChange) -> AppliedBlock:
+        """Apply a single edit and collect its change information."""
+        try:
+	        do_thing()
+====
+This would cause a syntax error, because do_thing is very likely followed by other code which would be kept outside the try block. The correct way to add a try block is to include all the code that should be inside the try block.
+
+Correct would be:
+Edit file
+<<<< original
+    def _apply_and_collect_change(self, edit: CodeChange) -> AppliedBlock:
+        """Apply a single edit and collect its change information."""
+        do_thing()
+        do_other_thing()
+>>>> modified
+    def _apply_and_collect_change(self, edit: CodeChange) -> AppliedBlock:
+        """Apply a single edit and collect its change information."""
+        try:
+            do_thing()
+            do_other_thing()
+        except Exception as e:
+            handle_exception(e)
+=====
+
+Final Summary:
+Provide a one line summary of the expected result of the changes.

janito/data/system_prompt.txt

@@ -0,0 +1,3 @@
+The assistant is an intelligent programmer, powered by Claude 3.5 Sonnet.
+It is happy to help answer any questions that the user has (usually about coding).
+

janito/qa.py

@@ -1,66 +1,56 @@
-from rich.console import Console
-from rich.markdown import Markdown
-from rich.panel import Panel
-from rich.syntax import Syntax
-from rich.table import Table
-from rich.rule import Rule
-from janito.agents import AIAgent
-from janito.common import progress_send_message
-from janito.workspace import workspace
-
-
-QA_PROMPT = """Please provide a clear and concise answer to the following question about the codebase:
-
-Question: {question}
-
-Current files:
-<files>
-{files_content}
-</files>
-
-Focus on providing factual information and explanations. Do not suggest code changes.
-Format your response using markdown with appropriate headers and code blocks.
-"""
-
-def ask_question(question: str, files_content: str) -> str:
-    """Process a question about the codebase and return the answer"""
-    # Analyze workspace content if needed
-    workspace.analyze()
-    
-    prompt = QA_PROMPT.format(
-        question=question,
-        files_content=files_content
-    )
-    return progress_send_message(prompt)
-
-
-def display_answer(answer: str, raw: bool = False) -> None:
-    """Display the answer as markdown with consistent colors"""
-    console = Console()
-    
-    # Define consistent colors
-    COLORS = {
-        'primary': '#729FCF',    # Soft blue for primary elements
-        'secondary': '#8AE234',  # Bright green for actions/success
-        'accent': '#AD7FA8',     # Purple for accents
-        'muted': '#7F9F7F',      # Muted green for less important text
-    }
-    
-    if raw:
-        console.print(answer)
-        return
-    
-    # Display markdown answer in a panel with consistent styling
-    answer_panel = Panel(
-        Markdown(answer),
-        title="[bold]Answer[/bold]",
-        title_align="center",
-        border_style=COLORS['primary'],
-        padding=(1, 2)
-    )
-    
-    console.print("\n")
-    console.print(Rule(style=COLORS['accent']))
-    console.print(answer_panel)
-    console.print(Rule(style=COLORS['accent']))
-    console.print("\n")
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.panel import Panel
+from janito.common import progress_send_message
+from janito.workspace import workset
+from pathlib import Path
+
+QA_PROMPT = """Please provide a clear and concise answer to the following question about the workset provided later.
+
+Question: {question}
+
+Focus on providing factual information and explanations. Do not suggest code changes.
+Format your response using markdown with appropriate headers and code blocks.
+
+workset content:
+{workset}
+"""
+
+def ask_question(question: str, file_filter: list[Path] = None) -> str:
+    """Process a question about the codebase and return the answer
+
+    Args:
+        question: The question to ask about the codebase
+        file_filter: list of paths to files to include in the workset
+
+    Returns:
+        str: The answer from the AI agent, or an error message if interrupted
+    """
+    workset.refresh()
+
+    prompt = QA_PROMPT.format(
+        question=question,
+        workset=workset.content
+    )
+    answer = progress_send_message(prompt)
+    
+    if answer is None:
+        return "Sorry, the response was interrupted. Please try asking your question again."
+    
+    return answer
+
+
+def display_answer(answer: str, raw: bool = False) -> None:
+    """Display the answer as markdown"""
+    if answer is None:
+        Console().print("\n[red]Error: No answer received - the response was interrupted[/red]\n")
+        return
+        
+    console = Console()
+
+    if raw:
+        console.print(answer)
+        return
+
+    # Display markdown answer directly
+    console.print(Markdown(answer))

janito/version.py

@@ -1,23 +1,23 @@
-"""Version management module for Janito."""
-from pathlib import Path
-from typing import Optional
-import tomli
-from importlib.metadata import version as pkg_version
-
-def get_version() -> str:
-    """
-    Get Janito version from package metadata or pyproject.toml.
-    
-    Returns:
-        str: The version string
-    """
-    try:
-        return pkg_version("janito")
-    except Exception:
-        # Fallback to pyproject.toml
-        pyproject_path = Path(__file__).parent.parent / "pyproject.toml"
-        if pyproject_path.exists():
-            with open(pyproject_path, "rb") as f:
-                pyproject_data = tomli.load(f)
-                return pyproject_data.get("project", {}).get("version", "unknown")
+"""Version management module for Janito."""
+from pathlib import Path
+from typing import Optional
+import tomli
+from importlib.metadata import version as pkg_version
+
+def get_version() -> str:
+    """
+    Get Janito version from package metadata or pyproject.toml.
+    
+    Returns:
+        str: The version string
+    """
+    try:
+        return pkg_version("janito")
+    except Exception:
+        # Fallback to pyproject.toml
+        pyproject_path = Path(__file__).parent.parent / "pyproject.toml"
+        if pyproject_path.exists():
+            with open(pyproject_path, "rb") as f:
+                pyproject_data = tomli.load(f)
+                return pyproject_data.get("project", {}).get("version", "unknown")
         return "unknown"

janito/workspace/__init__.py

@@ -1,7 +1,8 @@
-from .manager import WorkspaceManager
-from .scan import preview_scan, collect_files_content, is_dir_empty
-
-# Create singleton instance
-workspace = WorkspaceManager.get_instance()
-
-__all__ = ['workspace', 'preview_scan', 'collect_files_content', 'is_dir_empty']
+from .workset import Workset
+from .workspace import Workspace
+
+# Create and export singleton instance
+workset = Workset()
+workspace = Workspace()
+
+__all__ = ['workset', 'workspace']