devcouncil 0.1.0 → 0.1.1

package/src/devcouncil/indexing/graph_index.py

@@ -1,48 +1,48 @@
-from typing import List, Dict, Any, Set
-from pydantic import BaseModel, Field
-from pathlib import Path
-
-class GraphNode(BaseModel):
-    id: str
-    type: str # "file", "symbol", "requirement", "task"
-    metadata: Dict[str, Any] = Field(default_factory=dict)
-
-class GraphEdge(BaseModel):
-    source: str
-    target: str
-    relation: str # "imports", "implements", "validates", "contains"
-
-class KnowledgeGraph(BaseModel):
-    nodes: List[GraphNode] = []
-    edges: List[GraphEdge] = []
-
-class GraphIndex:
-    def __init__(self, project_root: Path):
-        self.project_root = project_root
-        self.graph = KnowledgeGraph()
-
-    def build_initial_graph(self, files: List[str]):
-        """
-        Bootstrap the graph from file list.
-        """
-        for f in files:
-            self.graph.nodes.append(GraphNode(
-                id=f,
-                type="file",
-                metadata={"extension": Path(f).suffix}
-            ))
-
-    def add_relation(self, source: str, target: str, relation: str):
-        self.graph.edges.append(GraphEdge(source=source, target=target, relation=relation))
-
-    def get_context_for_file(self, file_path: str) -> Set[str]:
-        """
-        Retrieve related paths for a given file.
-        """
-        related = {file_path}
-        for edge in self.graph.edges:
-            if edge.source == file_path:
-                related.add(edge.target)
-            if edge.target == file_path:
-                related.add(edge.source)
-        return related
+from typing import List, Dict, Any, Set
+from pydantic import BaseModel, Field
+from pathlib import Path
+
+class GraphNode(BaseModel):
+    id: str
+    type: str # "file", "symbol", "requirement", "task"
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+
+class GraphEdge(BaseModel):
+    source: str
+    target: str
+    relation: str # "imports", "implements", "validates", "contains"
+
+class KnowledgeGraph(BaseModel):
+    nodes: List[GraphNode] = []
+    edges: List[GraphEdge] = []
+
+class GraphIndex:
+    def __init__(self, project_root: Path):
+        self.project_root = project_root
+        self.graph = KnowledgeGraph()
+
+    def build_initial_graph(self, files: List[str]):
+        """
+        Bootstrap the graph from file list.
+        """
+        for f in files:
+            self.graph.nodes.append(GraphNode(
+                id=f,
+                type="file",
+                metadata={"extension": Path(f).suffix}
+            ))
+
+    def add_relation(self, source: str, target: str, relation: str):
+        self.graph.edges.append(GraphEdge(source=source, target=target, relation=relation))
+
+    def get_context_for_file(self, file_path: str) -> Set[str]:
+        """
+        Retrieve related paths for a given file.
+        """
+        related = {file_path}
+        for edge in self.graph.edges:
+            if edge.source == file_path:
+                related.add(edge.target)
+            if edge.target == file_path:
+                related.add(edge.source)
+        return related

package/src/devcouncil/indexing/lsp.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import json
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+@dataclass(frozen=True)
+class LspServerCandidate:
+    language: str
+    command: list[str]
+    available: bool
+    reason: str
+
+
+class LspInspector:
+    """Starter LSP integration focused on discovery and safe initialize payloads."""
+
+    _LANGUAGE_SERVERS: dict[str, list[list[str]]] = {
+        "python": [["pyright-langserver", "--stdio"], ["pylsp"]],
+        "typescript": [["typescript-language-server", "--stdio"]],
+        "javascript": [["typescript-language-server", "--stdio"]],
+        "go": [["gopls"]],
+        "rust": [["rust-analyzer"]],
+    }
+
+    _EXTENSIONS: dict[str, str] = {
+        ".py": "python",
+        ".ts": "typescript",
+        ".tsx": "typescript",
+        ".js": "javascript",
+        ".jsx": "javascript",
+        ".go": "go",
+        ".rs": "rust",
+    }
+    _IGNORED_DIRS = {".git", ".devcouncil", "__pycache__", ".venv", "node_modules", "dist", "build", "target", "vendor"}
+
+    def __init__(self, project_root: Path):
+        self.project_root = project_root
+
+    def _is_ignored_path(self, file: str) -> bool:
+        return any(part in self._IGNORED_DIRS for part in Path(file).parts)
+
+    def detect_languages(self, files: list[str] | None = None) -> list[str]:
+        if files is None:
+            try:
+                discovered: list[str] = []
+                for path in self.project_root.rglob("*"):
+                    if path.is_file() and not any(part in self._IGNORED_DIRS for part in path.parts):
+                        discovered.append(str(path.relative_to(self.project_root)))
+                files = discovered
+            except OSError:
+                files = []
+        languages = {
+            self._EXTENSIONS[Path(file).suffix.lower()]
+            for file in files
+            if Path(file).suffix.lower() in self._EXTENSIONS and not self._is_ignored_path(file)
+        }
+        return sorted(languages)
+
+    def server_candidates(self, files: list[str] | None = None) -> list[LspServerCandidate]:
+        candidates: list[LspServerCandidate] = []
+        for language in self.detect_languages(files):
+            for command in self._LANGUAGE_SERVERS.get(language, []):
+                executable = command[0]
+                available = shutil.which(executable) is not None
+                candidates.append(
+                    LspServerCandidate(
+                        language=language,
+                        command=command,
+                        available=available,
+                        reason="found on PATH" if available else "not found on PATH",
+                    )
+                )
+        return candidates
+
+    def initialize_request(self, language: str) -> dict[str, Any]:
+        return {
+            "jsonrpc": "2.0",
+            "id": 1,
+            "method": "initialize",
+            "params": {
+                "processId": None,
+                "rootUri": self.project_root.resolve().as_uri(),
+                "capabilities": {
+                    "textDocument": {
+                        "publishDiagnostics": {"relatedInformation": True},
+                        "definition": {"linkSupport": True},
+                        "references": {},
+                        "documentSymbol": {"hierarchicalDocumentSymbolSupport": True},
+                    },
+                    "workspace": {"symbol": {}},
+                },
+                "initializationOptions": {"language": language},
+            },
+        }
+
+    def summary(self, files: list[str] | None = None) -> dict[str, Any]:
+        candidates = self.server_candidates(files)
+        return {
+            "languages": self.detect_languages(files),
+            "servers": [
+                {
+                    "language": candidate.language,
+                    "command": candidate.command,
+                    "available": candidate.available,
+                    "reason": candidate.reason,
+                }
+                for candidate in candidates
+            ],
+            "initialize_requests": {
+                language: self.initialize_request(language)
+                for language in sorted({candidate.language for candidate in candidates})
+            },
+        }
+
+    def summary_json(self, files: list[str] | None = None) -> str:
+        return json.dumps(self.summary(files), indent=2)

package/src/devcouncil/indexing/repo_mapper.py

@@ -1,204 +1,208 @@
-import json
-import logging
-import os
-import subprocess
-from pathlib import Path
-from typing import List, Dict
-
-from pydantic import BaseModel
-
-logger = logging.getLogger(__name__)
-
-class RepoMap(BaseModel):
-    languages: List[str]
-    frameworks: List[str]
-    package_managers: List[str]
-    test_commands: List[str]
-    important_files: List[str]
-    candidate_files: List[Dict[str, str]]
-
-class RepoMapper:
-    def __init__(self, project_root: Path):
-        self.project_root = project_root
-
-    def _is_runtime_or_generated_file(self, path: str) -> bool:
-        normalized = path.replace("\\", "/")
-        parts = set(normalized.split("/"))
-        if "__pycache__" in parts or normalized.endswith(".pyc"):
-            return True
-        if parts.intersection({".git", ".devcouncil", ".pytest_cache", ".ruff_cache", ".mypy_cache", ".venv"}):
-            return True
-        if normalized.startswith("dist/") or normalized.startswith("build/"):
-            return True
-        return False
-
-    def get_git_files(self) -> List[str]:
-        try:
-            output = subprocess.check_output(
-                ["git", "ls-files", "--cached", "--others", "--exclude-standard"],
-                cwd=self.project_root,
-                stderr=subprocess.DEVNULL
-            ).decode().splitlines()
-            return [path for path in output if not self._is_runtime_or_generated_file(path)]
-        except Exception:
-            # Fallback to os.walk if not a git repo or git missing
-            files = []
-            for root, _, filenames in os.walk(self.project_root):
-                for f in filenames:
-                    rel_path = os.path.relpath(os.path.join(root, f), self.project_root)
-                    if not rel_path.startswith(".") and not self._is_runtime_or_generated_file(rel_path):
-                        files.append(rel_path)
-            return files
-
-    def detect_languages(self, files: List[str]) -> List[str]:
-        exts = {os.path.splitext(f)[1] for f in files}
-        lang_map = {
-            ".py": "python",
-            ".ts": "typescript",
-            ".tsx": "typescript",
-            ".js": "javascript",
-            ".jsx": "javascript",
-            ".go": "go",
-            ".rs": "rust",
-            ".java": "java",
-            ".c": "c",
-            ".cpp": "cpp",
-        }
-        return sorted(list({lang_map[ext] for ext in exts if ext in lang_map}))
-
-    def detect_frameworks(self, files: List[str]) -> List[str]:
-        frameworks = []
-        file_set = set(files)
-        if "package.json" in file_set:
-            content = (self.project_root / "package.json").read_text()
-            if "next" in content:
-                frameworks.append("nextjs")
-            if "react" in content:
-                frameworks.append("react")
-            if "vue" in content:
-                frameworks.append("vue")
-            if "express" in content:
-                frameworks.append("express")
-        
-        if "requirements.txt" in file_set or "pyproject.toml" in file_set:
-            try:
-                content = ""
-                if "requirements.txt" in file_set:
-                    content += (self.project_root / "requirements.txt").read_text()
-                if "pyproject.toml" in file_set:
-                    content += (self.project_root / "pyproject.toml").read_text()
-                
-                if "fastapi" in content.lower():
-                    frameworks.append("fastapi")
-                if "flask" in content.lower():
-                    frameworks.append("flask")
-                if "django" in content.lower():
-                    frameworks.append("django")
-            except Exception as e:
-                logger.debug("Failed to read Python config files: %s", e)
-        return frameworks
-
-    def detect_package_managers(self, files: List[str]) -> List[str]:
-        managers = []
-        file_set = set(files)
-        if "package-lock.json" in file_set:
-            managers.append("npm")
-        elif "package.json" in file_set:
-            managers.append("npm")
-        if "yarn.lock" in file_set:
-            managers.append("yarn")
-        if "pnpm-lock.yaml" in file_set:
-            managers.append("pnpm")
-        if "requirements.txt" in file_set:
-            managers.append("pip")
-        if "uv.lock" in file_set:
-            managers.append("uv")
-        if "go.sum" in file_set:
-            managers.append("go mod")
-        return managers
-
-    def detect_test_commands(self, files: List[str]) -> List[str]:
-        """Detect test, lint, and typecheck commands from project config."""
-        commands: List[str] = []
-        file_set = set(files)
-
-        # Node.js projects: read scripts from package.json
-        if "package.json" in file_set:
-            try:
-                pkg = json.loads((self.project_root / "package.json").read_text())
-                scripts = pkg.get("scripts", {})
-                pm = "pnpm" if "pnpm-lock.yaml" in file_set else (
-                    "yarn" if "yarn.lock" in file_set else "npm"
-                )
-                for key in ["test", "lint", "typecheck", "check", "type-check"]:
-                    if key in scripts:
-                        if pm == "npm" and key != "test":
-                            commands.append(f"npm run {key}")
-                        else:
-                            commands.append(f"{pm} {key}")
-            except Exception as e:
-                logger.debug("Failed to parse package.json scripts: %s", e)
-
-        # Python projects
-        if "pyproject.toml" in file_set or "setup.py" in file_set:
-            if any(f.startswith("tests/") or f.startswith("test_") for f in files):
-                commands.append("pytest")
-            commands.append("ruff check .")
-            commands.append("mypy .")
-
-        # Go projects
-        if "go.mod" in file_set:
-            commands.append("go test ./...")
-            commands.append("go vet ./...")
-
-        # Rust projects
-        if "Cargo.toml" in file_set:
-            commands.append("cargo test")
-            commands.append("cargo clippy")
-
-        return commands
-
-    def _ripgrep_search(self, goal: str, files: List[str]) -> List[Dict[str, str]]:
-        """Use ripgrep for goal-keyword search if available, else fall back to naive matching."""
-        candidates: List[Dict[str, str]] = []
-        try:
-            # Try ripgrep first for better matching
-            result = subprocess.run(
-                ["rg", "--files-with-matches", "--ignore-case", "--glob", "!.git", goal],
-                capture_output=True, text=True, cwd=self.project_root, timeout=10,
-            )
-            if result.returncode == 0:
-                for line in result.stdout.strip().splitlines()[:10]:
-                    candidates.append({"path": line.strip(), "reason": f"ripgrep match for '{goal}'"})
-                return candidates
-        except Exception:
-            pass  # Fall back to naive matching
-
-        # Naive keyword matching fallback
-        goal_words = set(goal.lower().split())
-        for f in files:
-            f_lower = f.lower()
-            score = sum(1 for word in goal_words if word in f_lower)
-            if score > 0:
-                candidates.append({"path": f, "reason": f"Matches goal keywords (score: {score})"})
-        candidates = sorted(candidates, key=lambda x: x.get("reason", ""), reverse=True)[:10]
-        return candidates
-
-    def map_repo(self, goal: str = "") -> RepoMap:
-        files = self.get_git_files()
-
-        candidates: List[Dict[str, str]] = []
-        if goal:
-            candidates = self._ripgrep_search(goal, files)
-
-        return RepoMap(
-            languages=self.detect_languages(files),
-            frameworks=self.detect_frameworks(files),
-            package_managers=self.detect_package_managers(files),
-            test_commands=self.detect_test_commands(files),
-            important_files=[f for f in files if f in [
-                "package.json", "pyproject.toml", "README.md", "go.mod",
-                "Cargo.toml", "Makefile", "Dockerfile", ".github/workflows",
-            ]],
-            candidate_files=candidates,
-        )
+import json
+import logging
+import os
+import subprocess
+from pathlib import Path
+from typing import List, Dict
+
+from pydantic import BaseModel, Field
+
+from devcouncil.indexing.lsp import LspInspector
+
+logger = logging.getLogger(__name__)
+
+class RepoMap(BaseModel):
+    languages: List[str]
+    frameworks: List[str]
+    package_managers: List[str]
+    test_commands: List[str]
+    important_files: List[str]
+    candidate_files: List[Dict[str, str]]
+    lsp: Dict[str, object] = Field(default_factory=dict)
+
+class RepoMapper:
+    def __init__(self, project_root: Path):
+        self.project_root = project_root
+
+    def _is_runtime_or_generated_file(self, path: str) -> bool:
+        normalized = path.replace("\\", "/")
+        parts = set(normalized.split("/"))
+        if "__pycache__" in parts or normalized.endswith(".pyc"):
+            return True
+        if parts.intersection({".git", ".devcouncil", ".pytest_cache", ".ruff_cache", ".mypy_cache", ".venv"}):
+            return True
+        if normalized.startswith("dist/") or normalized.startswith("build/"):
+            return True
+        return False
+
+    def get_git_files(self) -> List[str]:
+        try:
+            output = subprocess.check_output(
+                ["git", "ls-files", "--cached", "--others", "--exclude-standard"],
+                cwd=self.project_root,
+                stderr=subprocess.DEVNULL
+            ).decode().splitlines()
+            return [path for path in output if not self._is_runtime_or_generated_file(path)]
+        except Exception:
+            # Fallback to os.walk if not a git repo or git missing
+            files = []
+            for root, _, filenames in os.walk(self.project_root):
+                for f in filenames:
+                    rel_path = os.path.relpath(os.path.join(root, f), self.project_root)
+                    if not rel_path.startswith(".") and not self._is_runtime_or_generated_file(rel_path):
+                        files.append(rel_path)
+            return files
+
+    def detect_languages(self, files: List[str]) -> List[str]:
+        exts = {os.path.splitext(f)[1] for f in files}
+        lang_map = {
+            ".py": "python",
+            ".ts": "typescript",
+            ".tsx": "typescript",
+            ".js": "javascript",
+            ".jsx": "javascript",
+            ".go": "go",
+            ".rs": "rust",
+            ".java": "java",
+            ".c": "c",
+            ".cpp": "cpp",
+        }
+        return sorted(list({lang_map[ext] for ext in exts if ext in lang_map}))
+
+    def detect_frameworks(self, files: List[str]) -> List[str]:
+        frameworks = []
+        file_set = set(files)
+        if "package.json" in file_set:
+            content = (self.project_root / "package.json").read_text()
+            if "next" in content:
+                frameworks.append("nextjs")
+            if "react" in content:
+                frameworks.append("react")
+            if "vue" in content:
+                frameworks.append("vue")
+            if "express" in content:
+                frameworks.append("express")
+        
+        if "requirements.txt" in file_set or "pyproject.toml" in file_set:
+            try:
+                content = ""
+                if "requirements.txt" in file_set:
+                    content += (self.project_root / "requirements.txt").read_text()
+                if "pyproject.toml" in file_set:
+                    content += (self.project_root / "pyproject.toml").read_text()
+                
+                if "fastapi" in content.lower():
+                    frameworks.append("fastapi")
+                if "flask" in content.lower():
+                    frameworks.append("flask")
+                if "django" in content.lower():
+                    frameworks.append("django")
+            except Exception as e:
+                logger.debug("Failed to read Python config files: %s", e)
+        return frameworks
+
+    def detect_package_managers(self, files: List[str]) -> List[str]:
+        managers = []
+        file_set = set(files)
+        if "package-lock.json" in file_set:
+            managers.append("npm")
+        elif "package.json" in file_set:
+            managers.append("npm")
+        if "yarn.lock" in file_set:
+            managers.append("yarn")
+        if "pnpm-lock.yaml" in file_set:
+            managers.append("pnpm")
+        if "requirements.txt" in file_set:
+            managers.append("pip")
+        if "uv.lock" in file_set:
+            managers.append("uv")
+        if "go.sum" in file_set:
+            managers.append("go mod")
+        return managers
+
+    def detect_test_commands(self, files: List[str]) -> List[str]:
+        """Detect test, lint, and typecheck commands from project config."""
+        commands: List[str] = []
+        file_set = set(files)
+
+        # Node.js projects: read scripts from package.json
+        if "package.json" in file_set:
+            try:
+                pkg = json.loads((self.project_root / "package.json").read_text())
+                scripts = pkg.get("scripts", {})
+                pm = "pnpm" if "pnpm-lock.yaml" in file_set else (
+                    "yarn" if "yarn.lock" in file_set else "npm"
+                )
+                for key in ["test", "lint", "typecheck", "check", "type-check"]:
+                    if key in scripts:
+                        if pm == "npm" and key != "test":
+                            commands.append(f"npm run {key}")
+                        else:
+                            commands.append(f"{pm} {key}")
+            except Exception as e:
+                logger.debug("Failed to parse package.json scripts: %s", e)
+
+        # Python projects
+        if "pyproject.toml" in file_set or "setup.py" in file_set:
+            if any(f.startswith("tests/") or f.startswith("test_") for f in files):
+                commands.append("pytest")
+            commands.append("ruff check .")
+            commands.append("mypy .")
+
+        # Go projects
+        if "go.mod" in file_set:
+            commands.append("go test ./...")
+            commands.append("go vet ./...")
+
+        # Rust projects
+        if "Cargo.toml" in file_set:
+            commands.append("cargo test")
+            commands.append("cargo clippy")
+
+        return commands
+
+    def _ripgrep_search(self, goal: str, files: List[str]) -> List[Dict[str, str]]:
+        """Use ripgrep for goal-keyword search if available, else fall back to naive matching."""
+        candidates: List[Dict[str, str]] = []
+        try:
+            # Try ripgrep first for better matching
+            result = subprocess.run(
+                ["rg", "--files-with-matches", "--ignore-case", "--glob", "!.git", goal],
+                capture_output=True, text=True, cwd=self.project_root, timeout=10,
+            )
+            if result.returncode == 0:
+                for line in result.stdout.strip().splitlines()[:10]:
+                    candidates.append({"path": line.strip(), "reason": f"ripgrep match for '{goal}'"})
+                return candidates
+        except Exception:
+            pass  # Fall back to naive matching
+
+        # Naive keyword matching fallback
+        goal_words = set(goal.lower().split())
+        for f in files:
+            f_lower = f.lower()
+            score = sum(1 for word in goal_words if word in f_lower)
+            if score > 0:
+                candidates.append({"path": f, "reason": f"Matches goal keywords (score: {score})"})
+        candidates = sorted(candidates, key=lambda x: x.get("reason", ""), reverse=True)[:10]
+        return candidates
+
+    def map_repo(self, goal: str = "") -> RepoMap:
+        files = self.get_git_files()
+
+        candidates: List[Dict[str, str]] = []
+        if goal:
+            candidates = self._ripgrep_search(goal, files)
+
+        return RepoMap(
+            languages=self.detect_languages(files),
+            frameworks=self.detect_frameworks(files),
+            package_managers=self.detect_package_managers(files),
+            test_commands=self.detect_test_commands(files),
+            important_files=[f for f in files if f in [
+                "package.json", "pyproject.toml", "README.md", "go.mod",
+                "Cargo.toml", "Makefile", "Dockerfile", ".github/workflows",
+            ]],
+            candidate_files=candidates,
+            lsp=LspInspector(self.project_root).summary(files),
+        )