shotgun-sh 0.1.0.dev23__tar.gz → 0.1.0.dev25__tar.gz

{shotgun_sh-0.1.0.dev23 → shotgun_sh-0.1.0.dev25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shotgun-sh
-Version: 0.1.0.dev23
+Version: 0.1.0.dev25
 Summary: AI-powered research, planning, and task management CLI tool
 Project-URL: Homepage, https://shotgun.sh/
 Project-URL: Repository, https://github.com/shotgun-sh/shotgun

{shotgun_sh-0.1.0.dev23 → shotgun_sh-0.1.0.dev25}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "shotgun-sh"
-version = "0.1.0.dev23"
+version = "0.1.0.dev25"
 description = "AI-powered research, planning, and task management CLI tool"
 readme = "README.md"
 license = { text = "MIT" }

{shotgun_sh-0.1.0.dev23 → shotgun_sh-0.1.0.dev25}/src/shotgun/agents/common.py

@@ -62,7 +62,10 @@ async def add_system_status_message(
         Updated message history with system status message prepended
     """
     message_history = message_history or []
-    codebase_understanding_graphs = await deps.codebase_service.list_graphs()
+    # Only show graphs for the current working directory
+    codebase_understanding_graphs = (
+        await deps.codebase_service.list_graphs_for_directory()
+    )
 
     # Get existing files for the agent
     existing_files = get_agent_existing_files(deps.agent_mode)

{shotgun_sh-0.1.0.dev23 → shotgun_sh-0.1.0.dev25}/src/shotgun/codebase/core/ingestor.py

@@ -54,7 +54,7 @@ class Ingestor:
 
         # Node tables
         node_schemas = [
-            "CREATE NODE TABLE Project(name STRING PRIMARY KEY, repo_path STRING, graph_id STRING, created_at INT64, updated_at INT64, schema_version STRING, build_options STRING, node_count INT64, relationship_count INT64, stats_updated_at INT64, status STRING, current_operation_id STRING, last_operation STRING)",
+            "CREATE NODE TABLE Project(name STRING PRIMARY KEY, repo_path STRING, graph_id STRING, created_at INT64, updated_at INT64, schema_version STRING, build_options STRING, node_count INT64, relationship_count INT64, stats_updated_at INT64, status STRING, current_operation_id STRING, last_operation STRING, indexed_from_cwds STRING)",
             "CREATE NODE TABLE Package(qualified_name STRING PRIMARY KEY, name STRING, path STRING)",
             "CREATE NODE TABLE Folder(path STRING PRIMARY KEY, name STRING)",
             "CREATE NODE TABLE File(path STRING PRIMARY KEY, name STRING, extension STRING)",

{shotgun_sh-0.1.0.dev23 → shotgun_sh-0.1.0.dev25}/src/shotgun/codebase/core/manager.py

@@ -252,6 +252,7 @@ class CodebaseGraphManager:
         name: str,
         languages: list[str] | None,
         exclude_patterns: list[str] | None,
+        indexed_from_cwd: str | None = None,
     ) -> None:
         """Initialize the graph database and create initial metadata.
 
@@ -294,7 +295,8 @@ class CodebaseGraphManager:
                 last_operation: $last_operation,
                 node_count: 0,
                 relationship_count: 0,
-                stats_updated_at: $stats_updated_at
+                stats_updated_at: $stats_updated_at,
+                indexed_from_cwds: $indexed_from_cwds
             })
             """,
             {
@@ -311,6 +313,9 @@ class CodebaseGraphManager:
                 "current_operation_id": None,
                 "last_operation": None,
                 "stats_updated_at": int(time.time()),
+                "indexed_from_cwds": json.dumps(
+                    [indexed_from_cwd] if indexed_from_cwd else []
+                ),
             },
         )
 
@@ -323,6 +328,7 @@ class CodebaseGraphManager:
         name: str | None = None,
         languages: list[str] | None = None,
         exclude_patterns: list[str] | None = None,
+        indexed_from_cwd: str | None = None,
     ) -> CodebaseGraph:
         """Build a new code knowledge graph.
 
@@ -397,7 +403,8 @@ class CodebaseGraphManager:
                 created_at: $created_at,
                 updated_at: $updated_at,
                 schema_version: $schema_version,
-                build_options: $build_options
+                build_options: $build_options,
+                indexed_from_cwds: $indexed_from_cwds
             })
             """,
             {
@@ -410,6 +417,9 @@ class CodebaseGraphManager:
                 "build_options": json.dumps(
                     {"languages": languages, "exclude_patterns": exclude_patterns}
                 ),
+                "indexed_from_cwds": json.dumps(
+                    [indexed_from_cwd] if indexed_from_cwd else []
+                ),
             },
         )
 
@@ -475,6 +485,7 @@ class CodebaseGraphManager:
             status=GraphStatus.READY,
             last_operation=None,
             current_operation_id=None,
+            indexed_from_cwds=[indexed_from_cwd] if indexed_from_cwd else [],
         )
 
         # Update status to READY
@@ -1145,6 +1156,15 @@ class CodebaseGraphManager:
                     logger.debug(f"Failed to parse last operation stats: {e}")
                     last_operation = None
 
+            # Parse indexed_from_cwds - handle backward compatibility
+            indexed_from_cwds_json = project.get("indexed_from_cwds", "[]")
+            try:
+                indexed_from_cwds = (
+                    json.loads(indexed_from_cwds_json) if indexed_from_cwds_json else []
+                )
+            except (json.JSONDecodeError, TypeError):
+                indexed_from_cwds = []
+
             return CodebaseGraph(
                 graph_id=graph_id,
                 repo_path=project.get("repo_path", ""),
@@ -1165,6 +1185,7 @@ class CodebaseGraphManager:
                 status=status,
                 last_operation=last_operation,
                 current_operation_id=project.get("current_operation_id"),
+                indexed_from_cwds=indexed_from_cwds,
             )
         except Exception as e:
             logger.error(
@@ -1190,6 +1211,83 @@ class CodebaseGraphManager:
 
         return sorted(graphs, key=lambda g: g.updated_at, reverse=True)
 
+    async def add_cwd_access(self, graph_id: str, cwd: str | None = None) -> None:
+        """Add a working directory to a graph's access list.
+
+        Args:
+            graph_id: Graph ID to update
+            cwd: Working directory to add. If None, uses current working directory.
+        """
+        from pathlib import Path
+
+        if cwd is None:
+            cwd = str(Path.cwd().resolve())
+        else:
+            cwd = str(Path(cwd).resolve())
+
+        # Get current graph
+        graph = await self.get_graph(graph_id)
+        if not graph:
+            raise ValueError(f"Graph {graph_id} not found")
+
+        # Get current list
+        current_cwds = graph.indexed_from_cwds.copy()
+
+        # Add new CWD if not already present
+        if cwd not in current_cwds:
+            current_cwds.append(cwd)
+
+            # Update in database
+            await self._execute_query(
+                graph_id,
+                """
+                MATCH (p:Project {graph_id: $graph_id})
+                SET p.indexed_from_cwds = $indexed_from_cwds
+                """,
+                {
+                    "graph_id": graph_id,
+                    "indexed_from_cwds": json.dumps(current_cwds),
+                },
+            )
+            logger.info(f"Added CWD access for {cwd} to graph {graph_id}")
+
+    async def remove_cwd_access(self, graph_id: str, cwd: str) -> None:
+        """Remove a working directory from a graph's access list.
+
+        Args:
+            graph_id: Graph ID to update
+            cwd: Working directory to remove
+        """
+        from pathlib import Path
+
+        cwd = str(Path(cwd).resolve())
+
+        # Get current graph
+        graph = await self.get_graph(graph_id)
+        if not graph:
+            raise ValueError(f"Graph {graph_id} not found")
+
+        # Get current list
+        current_cwds = graph.indexed_from_cwds.copy()
+
+        # Remove CWD if present
+        if cwd in current_cwds:
+            current_cwds.remove(cwd)
+
+            # Update in database
+            await self._execute_query(
+                graph_id,
+                """
+                MATCH (p:Project {graph_id: $graph_id})
+                SET p.indexed_from_cwds = $indexed_from_cwds
+                """,
+                {
+                    "graph_id": graph_id,
+                    "indexed_from_cwds": json.dumps(current_cwds),
+                },
+            )
+            logger.info(f"Removed CWD access for {cwd} from graph {graph_id}")
+
     async def delete_graph(self, graph_id: str) -> None:
         """Delete a graph.
 
@@ -1365,6 +1463,7 @@ class CodebaseGraphManager:
         name: str,
         languages: list[str] | None,
         exclude_patterns: list[str] | None,
+        indexed_from_cwd: str | None = None,
     ) -> CodebaseGraph:
         """Internal implementation of graph building (runs in background)."""
         operation_id = str(uuid.uuid4())
@@ -1388,7 +1487,7 @@ class CodebaseGraphManager:
 
             # Do the actual build work
             graph = await self._do_build_graph(
-                graph_id, repo_path, name, languages, exclude_patterns
+                graph_id, repo_path, name, languages, exclude_patterns, indexed_from_cwd
             )
 
             # Update operation stats
@@ -1436,6 +1535,7 @@ class CodebaseGraphManager:
         name: str,
         languages: list[str] | None,
         exclude_patterns: list[str] | None,
+        indexed_from_cwd: str | None = None,
     ) -> CodebaseGraph:
         """Execute the actual graph building logic (extracted from original build_graph)."""
         # The database and Project node already exist from _initialize_graph_metadata
@@ -1515,6 +1615,7 @@ class CodebaseGraphManager:
         name: str | None = None,
         languages: list[str] | None = None,
         exclude_patterns: list[str] | None = None,
+        indexed_from_cwd: str | None = None,
     ) -> str:
         """Start building a new code knowledge graph asynchronously.
 
@@ -1547,12 +1648,13 @@ class CodebaseGraphManager:
             name=name,
             languages=languages,
             exclude_patterns=exclude_patterns,
+            indexed_from_cwd=indexed_from_cwd,
         )
 
         # Start the build operation in background
         task = asyncio.create_task(
             self._build_graph_impl(
-                graph_id, repo_path, name, languages, exclude_patterns
+                graph_id, repo_path, name, languages, exclude_patterns, indexed_from_cwd
             )
         )
         self._operations[graph_id] = task

{shotgun_sh-0.1.0.dev23 → shotgun_sh-0.1.0.dev25}/src/shotgun/codebase/models.py

@@ -73,6 +73,10 @@ class CodebaseGraph(BaseModel):
     current_operation_id: str | None = Field(
         None, description="ID of current in-progress operation"
     )
+    indexed_from_cwds: list[str] = Field(
+        default_factory=list,
+        description="List of working directories from which this graph is accessible. Empty list means globally accessible.",
+    )
 
 
 class QueryResult(BaseModel):

{shotgun_sh-0.1.0.dev23 → shotgun_sh-0.1.0.dev25}/src/shotgun/codebase/service.py

@@ -36,17 +36,57 @@ class CodebaseService:
         """
         return await self.manager.list_graphs()
 
-    async def create_graph(self, repo_path: str | Path, name: str) -> CodebaseGraph:
+    async def list_graphs_for_directory(
+        self, directory: Path | str | None = None
+    ) -> list[CodebaseGraph]:
+        """List graphs that match a specific directory.
+
+        Args:
+            directory: Directory to filter by. If None, uses current working directory.
+
+        Returns:
+            List of CodebaseGraph objects accessible from the specified directory
+        """
+        from pathlib import Path
+
+        if directory is None:
+            directory = Path.cwd()
+        elif isinstance(directory, str):
+            directory = Path(directory)
+
+        # Resolve to absolute path for comparison
+        target_path = str(directory.resolve())
+
+        # Get all graphs and filter by those accessible from this directory
+        all_graphs = await self.manager.list_graphs()
+        filtered_graphs = []
+
+        for graph in all_graphs:
+            # If indexed_from_cwds is empty, it's globally accessible (backward compatibility)
+            if not graph.indexed_from_cwds:
+                filtered_graphs.append(graph)
+            # Otherwise, check if current directory is in the allowed list
+            elif target_path in graph.indexed_from_cwds:
+                filtered_graphs.append(graph)
+
+        return filtered_graphs
+
+    async def create_graph(
+        self, repo_path: str | Path, name: str, indexed_from_cwd: str | None = None
+    ) -> CodebaseGraph:
         """Create and index a new graph from a repository.
 
         Args:
             repo_path: Path to the repository to index
             name: Human-readable name for the graph
+            indexed_from_cwd: Working directory from which indexing was initiated
 
         Returns:
             The created CodebaseGraph
         """
-        return await self.manager.build_graph(str(repo_path), name)
+        return await self.manager.build_graph(
+            str(repo_path), name, indexed_from_cwd=indexed_from_cwd
+        )
 
     async def get_graph(self, graph_id: str) -> CodebaseGraph | None:
         """Get graph metadata by ID.
@@ -59,6 +99,24 @@ class CodebaseService:
         """
         return await self.manager.get_graph(graph_id)
 
+    async def add_cwd_access(self, graph_id: str, cwd: str | None = None) -> None:
+        """Add a working directory to a graph's access list.
+
+        Args:
+            graph_id: Graph ID to update
+            cwd: Working directory to add. If None, uses current working directory.
+        """
+        await self.manager.add_cwd_access(graph_id, cwd)
+
+    async def remove_cwd_access(self, graph_id: str, cwd: str) -> None:
+        """Remove a working directory from a graph's access list.
+
+        Args:
+            graph_id: Graph ID to update
+            cwd: Working directory to remove
+        """
+        await self.manager.remove_cwd_access(graph_id, cwd)
+
     async def delete_graph(self, graph_id: str) -> None:
         """Delete a graph and its data.
 

{shotgun_sh-0.1.0.dev23 → shotgun_sh-0.1.0.dev25}/src/shotgun/prompts/agents/export.j2

@@ -4,6 +4,26 @@ Your job is to help export project documentation and findings to various formats
 
 {% include 'agents/partials/common_agent_system_prompt.j2' %}
 
+## MEMORY MANAGEMENT PROTOCOL
+
+- You can ONLY write to the `exports/` directory
+- SHOULD READ all files: `research.md`, `specification.md`, `plan.md`, `tasks.md`
+- Create new export files, don't modify source files
+- Name exports descriptively with timestamps: `exports/AGENTS_[timestamp].md`
+- Each export is a standalone deliverable for AI agents
+
+## AI AGENT PIPELINE AWARENESS
+
+**CRITICAL**: Your exports will be consumed by AI coding agents (Claude Code, Cursor, Windsurf, etc.)
+- The AGENTS.md file is THE primary deliverable for AI agents
+- Consolidate all relevant information into a single, actionable document
+- Include all necessary context without requiring access to source files
+- Structure exports for immediate AI agent consumption
+- Prioritize tasks and implementation steps from tasks.md
+- Include specifications and API details from specification.md
+- Add relevant research findings that affect implementation
+- Format as executable instructions, not educational content
+
 ## EXPORT WORKFLOW
 
 For export tasks:

{shotgun_sh-0.1.0.dev23 → shotgun_sh-0.1.0.dev25}/src/shotgun/prompts/agents/plan.j2

@@ -4,6 +4,28 @@ Your job is to help create comprehensive, actionable plans for software projects
 
 {% include 'agents/partials/common_agent_system_prompt.j2' %}
 
+## MEMORY MANAGEMENT PROTOCOL
+
+- You have exclusive write access to: `plan.md`
+- SHOULD READ `research.md` and `specification.md` for context but CANNOT write to them
+- This is your persistent memory store - ALWAYS load it first
+- Compress content regularly to stay within context limits
+- Keep your file updated as you work - it's your memory across sessions
+- When adding new plans, archive completed phases and compress old plans
+- Keep active plan at top, archived/completed plans compressed at bottom
+
+## AI AGENT PIPELINE AWARENESS
+
+**CRITICAL**: Your output will be consumed by AI coding agents (Claude Code, Cursor, Windsurf, etc.)
+- These agents already know how to code - don't teach programming concepts
+- Create implementation roadmaps, not learning paths
+- Each step must reference specific files and functions to create/modify
+- Replace "learn X" with "implement Y in file Z"
+- Include concrete validation checkpoints (run tests, check endpoints)
+- Break down into atomic, executable steps
+- Reference specific code patterns from the research
+- Every plan step should be a direct instruction an AI agent can execute
+
 ## PLANNING WORKFLOW
 
 For PLANNING tasks:

{shotgun_sh-0.1.0.dev23 → shotgun_sh-0.1.0.dev25}/src/shotgun/prompts/agents/research.j2

@@ -4,6 +4,27 @@ Your job is to help the user research various subjects related to their software
 
 {% include 'agents/partials/common_agent_system_prompt.j2' %}
 
+## MEMORY MANAGEMENT PROTOCOL
+
+- You have exclusive write access to: `research.md`
+- This is your persistent memory store - ALWAYS load it first
+- Compress content regularly to stay within context limits
+- Keep your file updated as you work - it's your memory across sessions
+- When adding new content, review and compress existing content if needed
+- Structure your memory as: Current Knowledge → Knowledge Gaps → New Findings → Compressed Summary
+
+## AI AGENT PIPELINE AWARENESS
+
+**CRITICAL**: Your output will be consumed by AI coding agents (Claude Code, Cursor, Windsurf, etc.)
+- These agents already know how to code - don't teach programming concepts
+- Focus on WHAT to build, not HOW to code
+- Research specific API endpoints, not general programming tutorials
+- Document exact library versions and compatibility requirements
+- Find configuration details and environment variables needed
+- Research existing codebase patterns for consistency
+- Format findings as actionable implementation details
+- Every research finding should directly inform what the AI agent will build
+
 ## RESEARCH WORKFLOW
 
 For research tasks:

{shotgun_sh-0.1.0.dev23 → shotgun_sh-0.1.0.dev25}/src/shotgun/prompts/agents/specify.j2

@@ -6,6 +6,29 @@ Transform requirements into detailed, actionable specifications that development
 
 {% include 'agents/partials/common_agent_system_prompt.j2' %}
 
+## MEMORY MANAGEMENT PROTOCOL
+
+- You have exclusive write access to: `specification.md`
+- SHOULD READ `research.md` for context but CANNOT write to it
+- This is your persistent memory store - ALWAYS load it first
+- Compress content regularly to stay within context limits
+- Keep your file updated as you work - it's your memory across sessions
+- When adding new specifications, review and consolidate overlapping requirements
+- Structure specifications for easy reference by the next agents
+
+## AI AGENT PIPELINE AWARENESS
+
+**CRITICAL**: Your output will be consumed by AI coding agents (Claude Code, Cursor, Windsurf, etc.)
+- These agents already know how to code - don't teach programming concepts
+- Create specifications that translate directly to code
+- Include exact file paths where features should be implemented
+- Define function signatures and API contracts
+- Specify test cases and acceptance criteria
+- Document integration points and dependencies
+- Structure specifications as implementation checklists
+- Ask clarifying questions about the target AI agent's capabilities
+- Every specification should be directly implementable by an AI agent
+
 ## SPECIFICATION WORKFLOW
 
 For specification tasks:

{shotgun_sh-0.1.0.dev23 → shotgun_sh-0.1.0.dev25}/src/shotgun/prompts/agents/tasks.j2

@@ -4,6 +4,29 @@ Your job is to help create and manage actionable tasks for software projects and
 
 {% include 'agents/partials/common_agent_system_prompt.j2' %}
 
+## MEMORY MANAGEMENT PROTOCOL
+
+- You have exclusive write access to: `tasks.md`
+- SHOULD READ `research.md`, `specification.md`, and `plan.md` for context but CANNOT write to them
+- This is your persistent memory store - ALWAYS load it first
+- Compress content regularly to stay within context limits
+- Keep your file updated as you work - it's your memory across sessions
+- Archive completed tasks to a compressed section at the bottom
+- Consolidate similar or duplicate tasks when compressing
+- Maintain structure: Active Tasks → Backlog → Archived (compressed)
+
+## AI AGENT PIPELINE AWARENESS
+
+**CRITICAL**: Your output will be consumed by AI coding agents (Claude Code, Cursor, Windsurf, etc.)
+- These agents already know how to code - don't teach programming concepts
+- Each task should be a specific file modification or creation
+- Format: "In [file path], [add/modify/delete] [specific code/feature]"
+- Include acceptance criteria as executable commands (npm test, curl endpoints)
+- Reference specific line numbers or function names when modifying existing code
+- Break complex features into atomic, single-file tasks when possible
+- Include validation steps that can be automated
+- Every task should be immediately executable by an AI agent without interpretation
+
 ## TASK MANAGEMENT WORKFLOW
 
 For task management:

{shotgun_sh-0.1.0.dev23 → shotgun_sh-0.1.0.dev25}/src/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_sh-0.1.0.dev23 → shotgun_sh-0.1.0.dev25}/src/shotgun/tui/screens/chat.py

@@ -378,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
 
@@ -651,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})",
@@ -662,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("")