issues-fs 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

issues_fs/issues/phase_1/Root__Selection__Service.py

@@ -0,0 +1,310 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Root__Selection__Service - Service for managing which folder is the current root
+# Phase 1: Enables selecting any folder with issue.json/node.json as the root
+# ═══════════════════════════════════════════════════════════════════════════════
+
+from typing                                                                                             import List
+from osbot_utils.type_safe.Type_Safe                                                                    import Type_Safe
+from osbot_utils.type_safe.primitives.core.Safe_UInt                                                    import Safe_UInt
+from osbot_utils.type_safe.primitives.domains.files.safe_str.Safe_Str__File__Path                       import Safe_Str__File__Path
+from osbot_utils.type_safe.type_safe_core.decorators.type_safe                                          import type_safe
+from osbot_utils.utils.Json                                                                             import json_loads
+from issues_fs.schemas.issues.phase_1.Schema__Root                     import Schema__Root__Candidate, Schema__Root__List__Response, Schema__Root__Current__Response, Schema__Root__Select__Response, Schema__Root__Select__Request
+from issues_fs.issues.graph_services.Graph__Repository         import Graph__Repository
+from issues_fs.issues.storage.Path__Handler__Graph_Node        import Path__Handler__Graph_Node, FILE_NAME__ISSUE_JSON, FILE_NAME__NODE_JSON
+
+
+class Root__Selection__Service(Type_Safe):                                       # Service for root folder selection
+    repository   : Graph__Repository                                             # Data access layer
+    path_handler : Path__Handler__Graph_Node                                     # Path generation
+    current_root : Safe_Str__File__Path                                          # Currently selected root path
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Get Available Roots
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def get_available_roots(self) -> Schema__Root__List__Response:               # Find all folders that could serve as roots
+        candidates = []
+
+        root_candidate = self.create_issues_root_candidate()                     # The .issues/ folder itself is always first
+        candidates.append(root_candidate)
+
+        issue_folders = self.scan_for_issue_folders()                            # Find all folders with issue.json or node.json
+        for folder_path in sorted(issue_folders):
+            candidate = self.create_candidate_from_folder(folder_path)
+            if candidate:
+                candidates.append(candidate)
+
+        return Schema__Root__List__Response(success = True            ,
+                                            roots   = candidates      ,
+                                            total   = Safe_UInt(len(candidates)))
+
+    def get_roots_with_children(self) -> Schema__Root__List__Response:           # Get only roots that have issues/ folders
+        all_roots = self.get_available_roots()
+
+        if all_roots.success is False:
+            return all_roots
+
+        roots_with_children = [r for r in all_roots.roots if r.has_issues is True]
+
+        return Schema__Root__List__Response(success = True                           ,
+                                            roots   = roots_with_children            ,
+                                            total   = Safe_UInt(len(roots_with_children)))
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Get/Set Current Root
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def get_current_root(self) -> Schema__Root__Current__Response:               # Get currently selected root
+        if not self.current_root:
+            return Schema__Root__Current__Response(success    = True            ,   # Default to .issues/ root
+                                                   path       = ''              ,
+                                                   label      = 'Root'          ,
+                                                   issue_type = 'root'          )
+
+        candidate = self.create_candidate_from_path(str(self.current_root))      # Create candidate for current root
+
+        if candidate is None:
+            return Schema__Root__Current__Response(success    = True                     ,
+                                                   path       = ''                       ,
+                                                   label      = 'Root'                   ,
+                                                   issue_type = 'root'                   ,
+                                                   message    = 'Previous root invalid, reset to default')
+
+        return Schema__Root__Current__Response(success    = True                  ,
+                                               path       = str(candidate.path)   ,
+                                               label      = str(candidate.label)  ,
+                                               issue_type = str(candidate.issue_type))
+
+    @type_safe
+    def set_current_root(self                          ,                         # Set the current root
+                         request : Schema__Root__Select__Request
+                    ) -> Schema__Root__Select__Response:
+        previous_root = self.current_root
+        new_path      = request.path
+
+        if self.is_valid_root(new_path) is False:                                # Validate new root
+            return Schema__Root__Select__Response(success  = False                          ,
+                                                  path     = ''                             ,
+                                                  previous = previous_root                  ,
+                                                  message  = f'Invalid root path: {new_path}')
+
+        self.current_root = new_path                                             # Set new root
+
+        return Schema__Root__Select__Response(success  = True          ,
+                                              path     = new_path      ,
+                                              previous = previous_root )
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Root Validation
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def is_valid_root(self, path: str) -> bool:                                  # Check if path is a valid root
+        if not path:
+            return True                                                          # Empty path = default root
+
+        base_path = str(self.path_handler.base_path)
+
+        if base_path and base_path != '.':
+            if path == base_path:                                                # base_path itself is always valid
+                return True
+
+        full_path = path
+        if base_path and base_path != '.':                                       # Build full path if relative
+            if path.startswith(base_path) is False:
+                full_path = f"{base_path}/{path}"
+
+        issue_json = f"{full_path}/{FILE_NAME__ISSUE_JSON}"                      # Check for issue.json or node.json
+        node_json  = f"{full_path}/{FILE_NAME__NODE_JSON}"
+
+        if self.repository.storage_fs.file__exists(issue_json):
+            return True
+        if self.repository.storage_fs.file__exists(node_json):
+            return True
+
+        return False
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Candidate Creation Helpers
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def create_issues_root_candidate(self) -> Schema__Root__Candidate:           # Create candidate for .issues/ root
+        base_path  = str(self.path_handler.base_path)
+        root_path  = self.path_handler.path_for_root_issue()
+        root_issue = self.load_issue_from_path(root_path)
+
+        effective_base = base_path if base_path and base_path != '.' else ''     # Normalize empty/dot to ''
+        has_issues     = self.has_issues_folder(effective_base)
+        child_count    = self.count_top_level_issues()
+
+        if root_issue:                                                           # If root issue.json exists
+            return Schema__Root__Candidate(path         = ''                                          ,
+                                           label        = root_issue.get('label', 'Root')             ,
+                                           title        = root_issue.get('title', 'Issues Root')      ,
+                                           issue_type   = root_issue.get('node_type', 'git-repo')     ,
+                                           depth        = Safe_UInt(0)                                ,
+                                           has_issues   = has_issues                                  ,
+                                           has_children = Safe_UInt(child_count)                      )
+
+        return Schema__Root__Candidate(path         = ''                     ,   # No root issue.json
+                                       label        = 'Root'                 ,
+                                       title        = 'Issues Root'          ,
+                                       issue_type   = 'root'                 ,
+                                       depth        = Safe_UInt(0)           ,
+                                       has_issues   = has_issues             ,
+                                       has_children = Safe_UInt(child_count) )
+
+    def create_candidate_from_folder(self, folder_path: str) -> Schema__Root__Candidate:  # Create candidate from folder
+        issue_data = self.load_issue_summary(folder_path)
+        if issue_data is None:
+            return None
+
+        base_path     = str(self.path_handler.base_path)
+        relative_path = folder_path
+
+        if base_path and base_path != '.':                                       # Make path relative if base_path is set
+            prefix = f"{base_path}/"
+            if folder_path.startswith(prefix):
+                relative_path = folder_path[len(prefix):]
+
+        depth        = self.calculate_depth(folder_path)
+        has_issues   = self.has_issues_folder(folder_path)
+        child_count  = self.count_children_in_folder(folder_path)
+
+        return Schema__Root__Candidate(path         = relative_path                           ,
+                                       label        = issue_data.get('label', '')             ,
+                                       title        = issue_data.get('title', '')             ,
+                                       issue_type   = issue_data.get('node_type', '')         ,
+                                       depth        = Safe_UInt(depth)                        ,
+                                       has_issues   = has_issues                              ,
+                                       has_children = Safe_UInt(child_count)                  )
+
+    def create_candidate_from_path(self, path: str) -> Schema__Root__Candidate:  # Create candidate from any path
+        if not path:
+            return self.create_issues_root_candidate()
+
+        base_path = str(self.path_handler.base_path)
+        full_path = path
+
+        if base_path and base_path != '.':                                       # Prepend base_path if set and path is relative
+            if path.startswith(base_path) is False:
+                full_path = f"{base_path}/{path}"
+
+        return self.create_candidate_from_folder(full_path)
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Folder Scanning
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def scan_for_issue_folders(self) -> List[str]:                               # Find all folders with issue/node.json
+        folders     = set()
+        all_paths   = self.repository.storage_fs.files__paths()
+        base_path   = str(self.path_handler.base_path)
+        data_prefix = f"{base_path}/data/" if base_path and base_path != '.' else "data/"
+
+        for path in all_paths:
+            if path.startswith(data_prefix) is False:
+                continue
+
+            if path.endswith(f'/{FILE_NAME__ISSUE_JSON}') or path.endswith(f'/{FILE_NAME__NODE_JSON}'):
+                folder = path.rsplit('/', 1)[0]                                  # Get parent folder
+                if folder != base_path and folder != '.':                        # Exclude root
+                    folders.add(folder)
+
+        return list(folders)
+
+    def has_issues_folder(self, folder_path: str) -> bool:                       # Check if folder has issues/ subfolder
+        issues_folder = f"{folder_path}/issues"
+        all_paths     = self.repository.storage_fs.files__paths()
+        prefix        = f"{issues_folder}/"
+
+        for path in all_paths:
+            if path.startswith(prefix):
+                return True
+
+        return False
+
+    def count_top_level_issues(self) -> int:                                     # Count issues in data/ folders
+        base_path = str(self.path_handler.base_path)
+        data_path = f"{base_path}/data/" if base_path and base_path != '.' else "data/"
+        all_paths = self.repository.storage_fs.files__paths()
+        folders   = set()
+
+        for path in all_paths:
+            if path.startswith(data_path) is False:
+                continue
+            if path.endswith(f'/{FILE_NAME__ISSUE_JSON}') or path.endswith(f'/{FILE_NAME__NODE_JSON}'):
+                folder = path.rsplit('/', 1)[0]
+                folders.add(folder)
+
+        return len(folders)
+
+    def count_children_in_folder(self, folder_path: str) -> int:                 # Count children in issues/ subfolder
+        issues_folder = f"{folder_path}/issues/"
+        all_paths     = self.repository.storage_fs.files__paths()
+        folders       = set()
+
+        for path in all_paths:
+            if path.startswith(issues_folder) is False:
+                continue
+            if path.endswith(f'/{FILE_NAME__ISSUE_JSON}') or path.endswith(f'/{FILE_NAME__NODE_JSON}'):
+                folder = path.rsplit('/', 1)[0]
+                folders.add(folder)
+
+        return len(folders)
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Issue Data Loading
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def load_issue_summary(self, folder_path: str) -> dict:                      # Load issue summary from folder
+        issue_path = f"{folder_path}/{FILE_NAME__ISSUE_JSON}"                    # Try issue.json first
+        data = self.load_issue_from_path(issue_path)
+        if data:
+            return data
+
+        node_path = f"{folder_path}/{FILE_NAME__NODE_JSON}"                      # Fall back to node.json
+        return self.load_issue_from_path(node_path)
+
+    def load_issue_from_path(self, file_path: str) -> dict:                      # Load issue data from specific path
+        if self.repository.storage_fs.file__exists(file_path) is False:
+            return None
+
+        content = self.repository.storage_fs.file__str(file_path)
+        if not content:
+            return None
+
+        return json_loads(content)
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Depth Calculation
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def calculate_depth(self, folder_path: str) -> int:                          # Calculate nesting depth from root
+        base_path = str(self.path_handler.base_path)
+
+        if not folder_path:
+            return 0
+
+        if base_path and base_path != '.':
+            if folder_path == base_path:
+                return 0
+
+            if folder_path.startswith(base_path) is False:
+                relative = folder_path                                           # Already relative
+            else:
+                relative = folder_path[len(base_path):].strip('/')               # Remove base path
+        else:
+            relative = folder_path.strip('/')                                    # No base path to remove
+
+        if not relative:
+            return 0
+
+        parts = relative.split('/')
+
+        depth = 0                                                                # Count issues/ segments for depth
+        for part in parts:
+            if part == 'issues':
+                depth += 1
+
+        return depth

issues_fs/issues/phase_1/__init__.py

@@ -0,0 +1,3 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Issue tracking services package
+# ═══════════════════════════════════════════════════════════════════════════════

issues_fs/issues/status/Git__Status__Service.py

@@ -0,0 +1,115 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Git__Status__Service - Git repository integration status
+# Detects git repository and provides integration information
+# ═══════════════════════════════════════════════════════════════════════════════
+
+import subprocess
+from osbot_utils.type_safe.Type_Safe                                                                        import Type_Safe
+from osbot_utils.type_safe.primitives.core.Safe_UInt                                                        import Safe_UInt
+from osbot_utils.type_safe.primitives.domains.common.safe_str.Safe_Str__Text                                import Safe_Str__Text
+from osbot_utils.type_safe.primitives.domains.files.safe_str.Safe_Str__File__Path import Safe_Str__File__Path
+
+from issues_fs.schemas.status.Schema__Git__Status import Schema__Git__Status
+
+
+class Git__Status__Service(Type_Safe):                                           # Git status service
+    root_path : Safe_Str__File__Path = ''                                              # Path to check for git
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Main Status Method
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def get_status(self) -> Schema__Git__Status:                                 # Get git status
+        work_dir = str(self.root_path) if self.root_path else None
+
+        is_git_repo = self._is_git_repository(work_dir)
+        if not is_git_repo:
+            return Schema__Git__Status(is_git_repo = False)
+
+        git_root       = self._get_git_root(work_dir)
+        current_branch = self._get_current_branch(work_dir)
+        current_commit = self._get_current_commit(work_dir)
+        is_dirty       = self._is_dirty(work_dir)
+        issues_tracked = self._is_issues_tracked(work_dir)
+        untracked      = self._count_untracked_issues(work_dir)
+        modified       = self._count_modified_issues(work_dir)
+        remote_name    = self._get_remote_name(work_dir)
+        remote_url     = self._get_remote_url(work_dir, remote_name)
+
+        return Schema__Git__Status(is_git_repo      = True                                  ,
+                                   git_root         = Safe_Str__Text(git_root)              ,
+                                   current_branch   = Safe_Str__Text(current_branch)        ,
+                                   current_commit   = Safe_Str__Text(current_commit)        ,
+                                   is_dirty         = is_dirty                              ,
+                                   issues_tracked   = issues_tracked                        ,
+                                   untracked_issues = Safe_UInt(untracked)                  ,
+                                   modified_issues  = Safe_UInt(modified)                   ,
+                                   remote_name      = Safe_Str__Text(remote_name)           ,
+                                   remote_url       = Safe_Str__Text(remote_url)            )
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Git Command Helpers
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def _run_git_command(self, args: list, work_dir: str = None) -> str:         # Run git command
+        try:
+            result = subprocess.run(['git'] + args                                          ,
+                                    cwd             = work_dir                              ,
+                                    capture_output  = True                                  ,
+                                    text            = True                                  ,
+                                    timeout         = 5                                     )
+            if result.returncode == 0:
+                return result.stdout.strip()
+        except Exception:
+            pass
+        return ''
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Status Detection Methods
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def _is_git_repository(self, work_dir: str = None) -> bool:                  # Check if git repo
+        result = self._run_git_command(['rev-parse', '--git-dir'], work_dir)
+        return bool(result)
+
+    def _get_git_root(self, work_dir: str = None) -> str:                        # Get git root path
+        return self._run_git_command(['rev-parse', '--show-toplevel'], work_dir)
+
+    def _get_current_branch(self, work_dir: str = None) -> str:                  # Get current branch
+        return self._run_git_command(['rev-parse', '--abbrev-ref', 'HEAD'], work_dir)
+
+    def _get_current_commit(self, work_dir: str = None) -> str:                  # Get short commit hash
+        return self._run_git_command(['rev-parse', '--short', 'HEAD'], work_dir)
+
+    def _is_dirty(self, work_dir: str = None) -> bool:                           # Check for uncommitted changes
+        result = self._run_git_command(['status', '--porcelain'], work_dir)
+        return bool(result)
+
+    def _is_issues_tracked(self, work_dir: str = None) -> bool:                  # Check if .issues is tracked
+        result = self._run_git_command(['ls-files', '.issues'], work_dir)
+        return bool(result)
+
+    def _count_untracked_issues(self, work_dir: str = None) -> int:              # Count untracked issue files
+        result = self._run_git_command(['ls-files', '--others', '--exclude-standard', '.issues'], work_dir)
+        if result:
+            return len(result.splitlines())
+        return 0
+
+    def _count_modified_issues(self, work_dir: str = None) -> int:               # Count modified issue files
+        result = self._run_git_command(['diff', '--name-only', '.issues'], work_dir)
+        if result:
+            return len(result.splitlines())
+        return 0
+
+    def _get_remote_name(self, work_dir: str = None) -> str:                     # Get first remote name
+        result = self._run_git_command(['remote'], work_dir)
+        if result:
+            remotes = result.splitlines()
+            if remotes:
+                return remotes[0]
+        return ''
+
+    def _get_remote_url(self, work_dir: str = None, remote_name: str = '') -> str:  # Get remote URL
+        if not remote_name:
+            return ''
+        return self._run_git_command(['remote', 'get-url', remote_name], work_dir)

issues_fs/issues/status/Index__Status__Service.py

@@ -0,0 +1,131 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Index__Status__Service - Index and node count statistics
+# Reports on global index and per-type node counts
+# ═══════════════════════════════════════════════════════════════════════════════
+
+from typing                                                                                                 import List
+from osbot_utils.type_safe.Type_Safe                                                                        import Type_Safe
+from osbot_utils.type_safe.primitives.core.Safe_UInt                                                        import Safe_UInt
+from osbot_utils.type_safe.primitives.domains.common.safe_str.Safe_Str__Text                                import Safe_Str__Text
+from issues_fs.schemas.status.Schema__Index__Status                        import Schema__Index__Status
+from issues_fs.schemas.status.Schema__Index__Status                        import Schema__Type__Count
+from issues_fs.issues.graph_services.Graph__Repository             import Graph__Repository
+from issues_fs.issues.graph_services.Type__Service                 import Type__Service
+
+# todo: see why we are using type_service below and not index_service
+
+class Index__Status__Service(Type_Safe):                                         # Index status service
+    repository   : Graph__Repository = None                                      # Graph__Repository instance
+    type_service : Type__Service = None                                          # Type__Service instance
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Main Status Method
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def get_status(self) -> Schema__Index__Status:                               # Get index status
+        if self.repository is None:
+            return Schema__Index__Status(global_index_exists = False             ,
+                                         type_counts         = []                )
+
+        global_exists = self._check_global_index_exists()
+        type_counts   = self._get_type_counts()
+        total_nodes   = self._calculate_total_nodes(type_counts)
+        #total_links   = self._count_total_links()
+        last_updated  = self._get_last_updated()
+
+        return Schema__Index__Status(global_index_exists = global_exists                     ,
+                                     total_nodes         = Safe_UInt(total_nodes)            ,
+                                     #total_links         = Safe_UInt(total_links)            ,
+                                     type_counts         = type_counts                       ,
+                                     last_updated        = Safe_Str__Text(last_updated)      )
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Index Checks
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def _check_global_index_exists(self) -> bool:                                # Check global index exists
+        index = self.repository.global_index_load()
+        return index is not None
+
+    def _get_last_updated(self) -> str:                                          # Get last update timestamp
+        try:
+            if hasattr(self.repository, 'global_index_load'):
+                index = self.repository.global_index_load()
+                if index and hasattr(index, 'last_updated'):
+                    return str(index.last_updated or '')
+        except Exception:
+            pass
+        return ''
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Type Counts
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+
+    def _get_type_counts(self) -> List[Schema__Type__Count]:                     # Get per-type counts
+        counts = []
+
+
+        # Get list of node types
+        node_type_names = self._get_node_type_names()
+
+        for type_name in node_type_names:
+            type_count  = self._get_count_for_type(type_name)
+            next_index  = self._get_next_index_for_type(type_name)
+
+            counts.append(Schema__Type__Count(node_type  = type_name     ,
+                                              count      = type_count    ,
+                                              next_index = next_index    ))
+
+        return counts
+
+    def _get_node_type_names(self) -> List[str]:                                 # Get all node type names
+        names = []
+
+        node_types = self.type_service.list_node_types()
+        if node_types:
+            for node_type in node_types:
+                name = node_type.name
+                if name:
+                    names.append(name)
+        return names
+
+    def _get_count_for_type(self, type_name: str) -> int:                        # Get node count for type
+        try:
+            if hasattr(self.repository, 'type_index_load'):
+                type_index = self.repository.type_index_load(type_name)
+                if type_index and hasattr(type_index, 'count'):
+                    return int(type_index.count)
+        except Exception:
+            pass
+        return 0
+
+    def _get_next_index_for_type(self, type_name: str) -> int:                   # Get next index for type
+        try:
+            if hasattr(self.repository, 'type_index_load'):
+                type_index = self.repository.type_index_load(type_name)
+                if type_index and hasattr(type_index, 'next_index'):
+                    return int(type_index.next_index)
+        except Exception:
+            pass
+        return 1
+
+    def _calculate_total_nodes(self, type_counts: List[Schema__Type__Count]) -> int:  # Sum all counts
+        total = 0
+        for tc in type_counts:
+            total += int(tc.count)
+        return total
+
+    # # ═══════════════════════════════════════════════════════════════════════════════
+    # # Link Counts
+    # # ═══════════════════════════════════════════════════════════════════════════════
+    #
+    # def _count_total_links(self) -> int:                                         # Count total links
+    #     total = 0
+    #     try:
+    #         # This would require loading all nodes and counting links
+    #         # For now, return 0 - can be enhanced to iterate nodes
+    #         pass
+    #     except Exception:
+    #         pass
+    #     return total