shotgun-sh 0.1.0.dev22__py3-none-any.whl → 0.1.0.dev24__py3-none-any.whl

shotgun/prompts/agents/research.j2

@@ -1,24 +1,19 @@
 You are an experienced Research Assistant.
 
-Your job is to help the user research various subjects related to their software project.
+Your job is to help the user research various subjects related to their software project and keep the research.md file up to date.
 
 {% include 'agents/partials/common_agent_system_prompt.j2' %}
 
 ## RESEARCH WORKFLOW
 
 For research tasks:
-1. **Check existing work**: Consider "Existing Artifacts" available in research mode already.
-IF NO SUITABLE ARTIFACT ALREADY EXISTS:
-  2. **Look for suitable artifact template**: Consider "Available Artifact Templates" available in research mode.
-  3. **Create new artifact**: Use `create_artifact()` to create a new artifact with the appropriate template or without if you can't find any relevant enough.
-4. **Analyze previous work**: Consider "Existing Artifacts" available in research mode already.
-5. **Identify gaps**: Determine what additional research is needed
-6. DO NOT ASSUME YOU KNOW THE ANSWER TO THE QUERY. ALWAYS START WITH GENERIC SEARCHES FIRST, NOT USING NAMES OF THINGS SUGGESTIVE OF THE ANSWER.
-7. **Search strategically**: Use web search to fill knowledge gaps (max 3 searches per session)
-8. **Synthesize findings**: Combine existing and new information
-9. **Create structured artifacts**: Use `write_artifact_section()` to organize findings
-
-Use meaningful artifact IDs like: "api-design-patterns", "microservices-study", "database-comparison"
+1. **Load previous research**: ALWAYS first use `read_file("research.md")` to see what research already exists (if the file exists)
+2. **Analyze existing work**: Understand what has been researched previously
+3. **Identify gaps**: Determine what additional research is needed
+4. DO NOT ASSUME YOU KNOW THE ANSWER TO THE QUERY. ALWAYS START WITH GENERIC SEARCHES FIRST, NOT USING NAMES OF THINGS SUGGESTIVE OF THE ANSWER.
+5. **Search strategically**: Use web search to fill knowledge gaps (max 3 searches per session)
+6. **Synthesize findings**: Combine existing and new information
+7. **Update research.md**: Use `write_file("research.md", content)` to save comprehensive, organized research
 
 ## RESEARCH PRINCIPLES
 
@@ -31,11 +26,13 @@ Use meaningful artifact IDs like: "api-design-patterns", "microservices-study",
 - Validate information from multiple sources
 - Document assumptions and limitations
 - Avoid analysis paralysis - be decisive with available information
-- Multi-Source Research -  Cross-reference multiple sources for accuracy and completeness
+- Multi-Source Research - Cross-reference multiple sources for accuracy and completeness
 - Critical Analysis - Evaluate trade-offs, limitations, and real-world applicability
 - Actionable Insights - Provide concrete recommendations and next steps when you're done
 - Comprehensive Citations - Include detailed source citations for verification
 - AVOID combining multiple topics into single search query. In fact, try similar queries across different providers/tools.
+- Keep research.md as the single source of truth
+- Organize findings by topic/category for easy reference
 
 ## Response Standards
 Your responses should always be:

shotgun/prompts/agents/specify.j2

@@ -1,6 +1,6 @@
 You are an experienced Specification Analyst.
 
-Your job is to help the user create comprehensive software specifications for their projects.
+Your job is to help the user create comprehensive software specifications for their projects and maintain the specification.md file.
 
 Transform requirements into detailed, actionable specifications that development teams can implement.
 
@@ -9,16 +9,11 @@ Transform requirements into detailed, actionable specifications that development
 ## SPECIFICATION WORKFLOW
 
 For specification tasks:
-0. **Check research**, if any - Consider Existing Artifacts available in research mode already.
-1. **Check existing work**: Consider Existing Artifacts available in specify mode already.
-IF NO SUITABLE ARTIFACT ALREADY EXISTS:
-  2. **Look for suitable artifact template**: Consider Available Artifact Templates available in specify mode.
-  3. **Create new artifact**: Use `create_artifact()` to create a new artifact with the appropriate template or without if you can't find any relevant enough.
-4. **Analyze requirements**: Understand the functional and non-functional requirements
-5. **Define specifications**: Create detailed technical and functional specifications
-6. **Structure documentation**: Use `write_artifact_section()` to organize specifications
-
-Use meaningful artifact IDs like: "user-auth-spec", "api-gateway-spec", "data-model-spec"
+1. **Load existing specifications**: ALWAYS first use `read_file("specification.md")` to see what specifications already exist (if the file exists)
+2. **Check research**: Read `research.md` if it exists to understand technical context and findings
+3. **Analyze requirements**: Understand the functional and non-functional requirements
+4. **Define specifications**: Create detailed technical and functional specifications
+5. **Structure documentation**: Use `write_file("specification.md", content)` to save comprehensive specifications
 
 ## SPECIFICATION PRINCIPLES
 
@@ -28,4 +23,6 @@ Use meaningful artifact IDs like: "user-auth-spec", "api-gateway-spec", "data-mo
 - **Traceability**: Link specifications back to original requirements and business needs
 - **Testability**: Define clear acceptance criteria and testing approaches
 - **Maintainability**: Structure specifications for easy updates and modifications
-- **Stakeholder Focus**: Consider different audiences (developers, testers, business users)
+- **Stakeholder Focus**: Consider different audiences (developers, testers, business users)
+- Keep specification.md as the single source of truth
+- Organize specifications by features, components, or user stories

shotgun/prompts/agents/state/system_state.j2

@@ -1,9 +1,31 @@
-{% if current_date %}
 ## System Status
 
-Today's date: {{ current_date }}
+{% include 'agents/state/codebase/codebase_graphs_available.j2' %}
+
+## Available Files
 
+{% if existing_files %}
+The following files already exist in the .shotgun/ directory.
+Before doing a web search check the information information in these files before continuing.
+Your working files are:
+{% for file in existing_files %}
+- `{{ file }}`
+{% endfor %}
+{% else %}
+No files currently exist in your allowed directories. You can create:
+- `research.md` - Research findings and analysis
+- `plan.md` - Project plans and roadmaps
+- `tasks.md` - Task lists and management
+- `specification.md` - Technical specifications
+- `exports/` folder - For exported documents
 {% endif %}
-{% include 'agents/state/codebase/codebase_graphs_available.j2' %}
-{% include 'agents/state/existing_artifacts_available.j2' %}
-{% include 'agents/state/artifact_templates_available.j2' %}
+
+{% if markdown_toc %}
+## Document Structure
+
+The current document contains the following sections:
+```
+{{ markdown_toc }}
+```
+Review these existing sections before adding new content to avoid duplication.
+{% endif %}

shotgun/prompts/agents/tasks.j2

@@ -1,27 +1,25 @@
 You are an experienced Project Manager and Task Coordinator.
 
-Your job is to help create and manage actionable tasks for software projects.
+Your job is to help create and manage actionable tasks for software projects and maintain the tasks.md file.
 
 {% include 'agents/partials/common_agent_system_prompt.j2' %}
 
 ## TASK MANAGEMENT WORKFLOW
 
 For task management:
-1. **Check existing work**: Use `list_artifacts("tasks")` to see what tasks already exist
-2. **Review context**: Use `list_artifacts("plan")` and `list_artifacts("specify")` to understand project context
+1. **Load existing tasks**: ALWAYS first use `read_file("tasks.md")` to see what tasks already exist (if the file exists)
+2. **Review context**: Read `plan.md` and `specification.md` if they exist to understand project context
 3. **Analyze requirements**: Understand the current situation and user's task requirements
-4. **Create structured tasks**: Use `write_artifact_section()` to organize task output
+4. **Create structured tasks**: Use `write_file("tasks.md", content)` to save organized tasks
 5. **Build incrementally**: Update and refine tasks based on new information
 
-## TASK ARTIFACT STRUCTURE
+## TASK FILE STRUCTURE
 
-Organize tasks into logical sections:
-- **Section 1: Backlog** - Prioritized list of tasks to be done
-- **Section 2: In Progress** - Current active tasks and status
-- **Section 3: Done** - Completed tasks for reference
-- **Section 4: Blocked** - Tasks waiting on dependencies or decisions
-
-Use meaningful artifact IDs like: "feature-development", "migration-tasks", "testing-checklist"
+Organize tasks into logical sections in tasks.md:
+- **Backlog** - Prioritized list of tasks to be done
+- **In Progress** - Current active tasks and status
+- **Done** - Completed tasks for reference
+- **Blocked** - Tasks waiting on dependencies or decisions
 
 ## TASK CREATION PRINCIPLES
 
@@ -33,6 +31,8 @@ Use meaningful artifact IDs like: "feature-development", "migration-tasks", "tes
 - Align with goals and steps from project plans
 - Include both development and testing/validation tasks
 - Break down complex work into manageable chunks
+- Keep tasks.md as the single source of truth
+- Use clear task IDs or numbers for tracking
 
 {% if interactive_mode %}
 USER INTERACTION - ASK CLARIFYING QUESTIONS:

shotgun/sdk/codebase.py

@@ -43,12 +43,30 @@ class CodebaseSDK:
         graphs = await self.service.list_graphs()
         return ListResult(graphs=graphs)
 
-    async def index_codebase(self, path: Path, name: str) -> IndexResult:
+    async def list_codebases_for_directory(
+        self, directory: Path | None = None
+    ) -> ListResult:
+        """List codebases accessible from a specific directory.
+
+        Args:
+            directory: Directory to filter by. If None, uses current working directory.
+
+        Returns:
+            ListResult containing filtered list of codebases
+        """
+        graphs = await self.service.list_graphs_for_directory(directory)
+        return ListResult(graphs=graphs)
+
+    async def index_codebase(
+        self, path: Path, name: str, indexed_from_cwd: str | None = None
+    ) -> IndexResult:
         """Index a new codebase.
 
         Args:
             path: Path to the repository to index
             name: Human-readable name for the codebase
+            indexed_from_cwd: Working directory from which indexing was initiated.
+                            If None, uses current working directory.
 
         Returns:
             IndexResult with indexing details
@@ -60,7 +78,13 @@ class CodebaseSDK:
         if not resolved_path.exists():
             raise InvalidPathError(f"Path does not exist: {resolved_path}")
 
-        graph = await self.service.create_graph(resolved_path, name)
+        # Default to current working directory if not specified
+        if indexed_from_cwd is None:
+            indexed_from_cwd = str(Path.cwd().resolve())
+
+        graph = await self.service.create_graph(
+            resolved_path, name, indexed_from_cwd=indexed_from_cwd
+        )
         file_count = sum(graph.language_stats.values()) if graph.language_stats else 0
 
         return IndexResult(

shotgun/sdk/services.py

@@ -2,7 +2,6 @@
 
 from pathlib import Path
 
-from shotgun.artifacts.service import ArtifactService
 from shotgun.codebase.service import CodebaseService
 from shotgun.utils import get_shotgun_home
 
@@ -22,16 +21,3 @@ def get_codebase_service(storage_dir: Path | str | None = None) -> CodebaseServi
     elif isinstance(storage_dir, str):
         storage_dir = Path(storage_dir)
     return CodebaseService(storage_dir)
-
-
-def get_artifact_service(base_path: Path | None = None) -> ArtifactService:
-    """Get ArtifactService instance with configurable base path.
-
-    Args:
-        base_path: Optional base path for artifacts.
-                   Defaults to .shotgun in current directory.
-
-    Returns:
-        Configured ArtifactService instance
-    """
-    return ArtifactService(base_path)

shotgun/tui/app.py

@@ -29,10 +29,13 @@ class ShotgunApp(App[None]):
     ]
     CSS_PATH = "styles.tcss"
 
-    def __init__(self, no_update_check: bool = False) -> None:
+    def __init__(
+        self, no_update_check: bool = False, continue_session: bool = False
+    ) -> None:
         super().__init__()
         self.config_manager: ConfigManager = get_config_manager()
         self.no_update_check = no_update_check
+        self.continue_session = continue_session
         self.update_notification: str | None = None
 
         # Start async update check
@@ -77,7 +80,8 @@ class ShotgunApp(App[None]):
 
         if isinstance(self.screen, ChatScreen):
             return
-        self.push_screen("chat")
+        # Pass continue_session flag to ChatScreen
+        self.push_screen(ChatScreen(continue_session=self.continue_session))
 
     def check_local_shotgun_directory_exists(self) -> bool:
         shotgun_dir = get_shotgun_base_path()
@@ -97,13 +101,14 @@ class ShotgunApp(App[None]):
         return []  # we don't want any system commands
 
 
-def run(no_update_check: bool = False) -> None:
+def run(no_update_check: bool = False, continue_session: bool = False) -> None:
     """Run the TUI application.
 
     Args:
         no_update_check: If True, disable automatic update checks.
+        continue_session: If True, continue from previous conversation.
     """
-    app = ShotgunApp(no_update_check=no_update_check)
+    app = ShotgunApp(no_update_check=no_update_check, continue_session=continue_session)
     app.run(inline_no_clear=True)
 
 

shotgun/tui/screens/chat.py

@@ -22,13 +22,18 @@ from textual.widgets import Button, DirectoryTree, Input, Label, Markdown, Stati
 
 from shotgun.agents.agent_manager import (
     AgentManager,
-    AgentType,
     MessageHistoryUpdated,
     PartialResponseMessage,
 )
 from shotgun.agents.config import get_provider_model
+from shotgun.agents.conversation_history import (
+    ConversationHistory,
+    ConversationState,
+)
+from shotgun.agents.conversation_manager import ConversationManager
 from shotgun.agents.models import (
     AgentDeps,
+    AgentType,
     FileOperationTracker,
     UserAnswer,
     UserQuestion,
@@ -36,7 +41,7 @@ from shotgun.agents.models import (
 from shotgun.codebase.core.manager import CodebaseAlreadyIndexedError
 from shotgun.sdk.codebase import CodebaseSDK
 from shotgun.sdk.exceptions import CodebaseNotFoundError, InvalidPathError
-from shotgun.sdk.services import get_artifact_service, get_codebase_service
+from shotgun.sdk.services import get_codebase_service
 from shotgun.tui.commands import CommandHandler
 from shotgun.tui.screens.chat_screen.history import ChatHistory
 
@@ -323,12 +328,11 @@ class ChatScreen(Screen[None]):
     indexing_job: reactive[CodebaseIndexSelection | None] = reactive(None)
     partial_message: reactive[ModelMessage | None] = reactive(None)
 
-    def __init__(self) -> None:
+    def __init__(self, continue_session: bool = False) -> None:
         super().__init__()
         # Get the model configuration and services
         model_config = get_provider_model()
         codebase_service = get_codebase_service()
-        artifact_service = get_artifact_service()
         self.codebase_sdk = CodebaseSDK()
 
         # Create shared deps without system_prompt_fn (agents provide their own)
@@ -343,17 +347,23 @@ class ChatScreen(Screen[None]):
             is_tui_context=True,
             llm_model=model_config,
             codebase_service=codebase_service,
-            artifact_service=artifact_service,
             system_prompt_fn=_placeholder_system_prompt_fn,
         )
         self.agent_manager = AgentManager(deps=self.deps, initial_type=self.mode)
         self.command_handler = CommandHandler()
         self.placeholder_hints = PlaceholderHints()
+        self.conversation_manager = ConversationManager()
+        self.continue_session = continue_session
 
     def on_mount(self) -> None:
         self.query_one(PromptInput).focus(scroll_visible=True)
         # Hide spinner initially
         self.query_one("#spinner").display = False
+
+        # Load conversation history if --continue flag was provided
+        if self.continue_session and self.conversation_manager.exists():
+            self._load_conversation()
+
         self.call_later(self.check_if_codebase_is_indexed)
         # Start the question listener worker to handle ask_user interactions
         self.call_later(self.add_question_listener)
@@ -368,16 +378,11 @@ class ChatScreen(Screen[None]):
         if is_empty:
             return
 
-        # find at least one codebase that is indexed in the current directory
-        directory_indexed = next(
-            (
-                dir
-                for dir in (await self.codebase_sdk.list_codebases()).graphs
-                if cur_dir.is_relative_to(Path(dir.repo_path).resolve())
-            ),
-            None,
-        )
-        if directory_indexed:
+        # Check if the current directory has any accessible codebases
+        accessible_graphs = (
+            await self.codebase_sdk.list_codebases_for_directory()
+        ).graphs
+        if accessible_graphs:
             self.mount_hint(help_text_with_codebase())
             return
 
@@ -478,6 +483,10 @@ class ChatScreen(Screen[None]):
         if not chat_history.vertical_tail:
             return
         chat_history.vertical_tail.mount(Markdown(markdown))
+        # Scroll to bottom after mounting hint
+        chat_history.vertical_tail.call_after_refresh(
+            chat_history.vertical_tail.scroll_end, animate=False
+        )
 
     @on(PartialResponseMessage)
     def handle_partial_response(self, event: PartialResponseMessage) -> None:
@@ -590,9 +599,7 @@ class ChatScreen(Screen[None]):
         Returns:
             Dynamic placeholder hint based on mode and progress.
         """
-        return self.placeholder_hints.get_placeholder_for_mode(
-            mode, force_new=force_new
-        )
+        return self.placeholder_hints.get_placeholder_for_mode(mode)
 
     def index_codebase_command(self) -> None:
         start_path = Path.cwd()
@@ -639,8 +646,18 @@ class ChatScreen(Screen[None]):
         )
         label.refresh()
         try:
+            # Pass the current working directory as the indexed_from_cwd
+            logger.debug(
+                f"Starting indexing - repo_path: {selection.repo_path}, "
+                f"name: {selection.name}, cwd: {Path.cwd().resolve()}"
+            )
             result = await self.codebase_sdk.index_codebase(
-                selection.repo_path, selection.name
+                selection.repo_path,
+                selection.name,
+                indexed_from_cwd=str(Path.cwd().resolve()),
+            )
+            logger.info(
+                f"Successfully indexed codebase '{result.name}' (ID: {result.graph_id})"
             )
             self.notify(
                 f"Indexed codebase '{result.name}' (ID: {result.graph_id})",
@@ -650,12 +667,19 @@ class ChatScreen(Screen[None]):
 
             self.mount_hint(codebase_indexed_hint(selection.name))
         except CodebaseAlreadyIndexedError as exc:
+            logger.warning(f"Codebase already indexed: {exc}")
             self.notify(str(exc), severity="warning")
             return
         except InvalidPathError as exc:
+            logger.error(f"Invalid path error: {exc}")
             self.notify(str(exc), severity="error")
 
         except Exception as exc:  # pragma: no cover - defensive UI path
+            # Log full exception details with stack trace
+            logger.exception(
+                f"Failed to index codebase - repo_path: {selection.repo_path}, "
+                f"name: {selection.name}, error: {exc}"
+            )
             self.notify(f"Failed to index codebase: {exc}", severity="error")
         finally:
             label.update("")
@@ -690,9 +714,46 @@ class ChatScreen(Screen[None]):
         )
         self.working = False
 
+        # Save conversation after each interaction
+        self._save_conversation()
+
         prompt_input = self.query_one(PromptInput)
         prompt_input.focus()
 
+    def _save_conversation(self) -> None:
+        """Save the current conversation to persistent storage."""
+        # Get conversation state from agent manager
+        state = self.agent_manager.get_conversation_state()
+
+        # Create conversation history object
+        conversation = ConversationHistory(
+            last_agent_model=state.agent_type,
+        )
+        conversation.set_agent_messages(state.agent_messages)
+
+        # Save to file
+        self.conversation_manager.save(conversation)
+
+    def _load_conversation(self) -> None:
+        """Load conversation from persistent storage."""
+        conversation = self.conversation_manager.load()
+        if conversation is None:
+            return
+
+        # Restore agent state
+        agent_messages = conversation.get_agent_messages()
+
+        # Create ConversationState for restoration
+        state = ConversationState(
+            agent_messages=agent_messages,
+            agent_type=conversation.last_agent_model,
+        )
+
+        self.agent_manager.restore_conversation_state(state)
+
+        # Update the current mode
+        self.mode = AgentType(conversation.last_agent_model)
+
 
 def codebase_indexed_hint(codebase_name: str) -> str:
     return (

shotgun/tui/screens/chat_screen/command_providers.py

@@ -3,7 +3,7 @@ from typing import TYPE_CHECKING, cast
 
 from textual.command import DiscoveryHit, Hit, Provider
 
-from shotgun.agents.agent_manager import AgentType
+from shotgun.agents.models import AgentType
 from shotgun.codebase.models import CodebaseGraph
 
 if TYPE_CHECKING:

shotgun/tui/screens/chat_screen/history.py

@@ -187,6 +187,12 @@ class AgentResponseWidget(Widget):
     def _format_tool_call_part(self, part: ToolCallPart) -> str:
         if part.tool_name == "ask_user":
             return self._format_ask_user_part(part)
+        # write_file
+        if part.tool_name == "write_file" or part.tool_name == "append_file":
+            if isinstance(part.args, dict) and "filename" in part.args:
+                return f"{part.tool_name}({part.args['filename']})"
+            else:
+                return f"{part.tool_name}()"
         if part.tool_name == "write_artifact_section":
             if isinstance(part.args, dict) and "section_title" in part.args:
                 return f"{part.tool_name}({part.args['section_title']})"