devcouncil 0.1.1 → 0.2.1

package/src/devcouncil/indexing/repo_mapper.py

@@ -1,208 +0,0 @@
-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),
-        )

package/src/devcouncil/integrations/code_review_graph.py

@@ -1,163 +0,0 @@
-import json
-import shutil
-import subprocess
-from pathlib import Path
-from typing import Any, Iterable
-
-from pydantic import BaseModel, Field
-
-from devcouncil.app.config import load_config
-
-
-class CodeReviewGraphContext(BaseModel):
-    available: bool
-    summary: str
-    command: str = "code-review-graph"
-    changed_files: list[str] = Field(default_factory=list)
-    impacted_files: list[str] = Field(default_factory=list)
-    related_tests: list[str] = Field(default_factory=list)
-    raw: str = ""
-
-
-class CodeReviewGraphAdapter:
-    """Optional shell adapter for code-review-graph without a hard dependency."""
-
-    def __init__(self, project_root: Path, command: str | None = None):
-        self.project_root = project_root
-        self.command = command or self._configured_command()
-
-    def is_enabled(self) -> bool:
-        try:
-            return load_config(self.project_root).integrations.code_review_graph.enabled
-        except Exception:
-            return False
-
-    def is_available(self) -> bool:
-        return shutil.which(self.command) is not None
-
-    def get_context(self, files: Iterable[str] = ()) -> CodeReviewGraphContext:
-        changed_files = [file for file in files if file]
-        if not self.is_enabled():
-            return CodeReviewGraphContext(
-                available=False,
-                summary="code-review-graph integration is disabled.",
-                command=self.command,
-                changed_files=changed_files,
-            )
-        if not self.is_available():
-            return CodeReviewGraphContext(
-                available=False,
-                summary="code-review-graph command was not found on PATH.",
-                command=self.command,
-                changed_files=changed_files,
-            )
-
-        commands = self._candidate_commands(changed_files)
-        errors: list[str] = []
-        for command in commands:
-            result = self._run(command)
-            if result.returncode == 0 and result.output.strip():
-                return self._parse_context(result.output, changed_files)
-            errors.append(result.output.strip() or f"exit {result.returncode}")
-
-        return CodeReviewGraphContext(
-            available=True,
-            summary="code-review-graph ran but did not return context.",
-            command=self.command,
-            changed_files=changed_files,
-            raw="\n".join(errors),
-        )
-
-    def prompt_section(self, files: Iterable[str] = ()) -> str:
-        context = self.get_context(files)
-        if not context.available:
-            return ""
-
-        lines = ["## Structural graph context", context.summary]
-        if context.impacted_files:
-            lines.append("\nImpacted files:")
-            lines.extend(f"- `{path}`" for path in context.impacted_files[:20])
-        if context.related_tests:
-            lines.append("\nRelated tests:")
-            lines.extend(f"- `{path}`" for path in context.related_tests[:20])
-        return "\n".join(lines).strip() + "\n"
-
-    def _configured_command(self) -> str:
-        try:
-            return load_config(self.project_root).integrations.code_review_graph.command
-        except Exception:
-            return "code-review-graph"
-
-    def _candidate_commands(self, files: list[str]) -> list[list[str]]:
-        commands = [[self.command, "detect-changes", "--json"]]
-        if files:
-            commands.append([self.command, "get-review-context", "--json", *files])
-        commands.append([self.command, "status", "--json"])
-        return commands
-
-    def _parse_context(self, output: str, changed_files: list[str]) -> CodeReviewGraphContext:
-        data: dict[str, Any] = {}
-        try:
-            parsed = json.loads(output)
-            if isinstance(parsed, dict):
-                data = parsed
-        except json.JSONDecodeError:
-            pass
-
-        impacted = self._string_list(
-            data.get("impacted_files")
-            or data.get("impact_radius")
-            or data.get("files")
-            or []
-        )
-        tests = self._string_list(data.get("related_tests") or data.get("tests") or [])
-        summary = str(data.get("summary") or "code-review-graph context available.")
-        return CodeReviewGraphContext(
-            available=True,
-            summary=summary,
-            command=self.command,
-            changed_files=changed_files,
-            impacted_files=impacted,
-            related_tests=tests,
-            raw=output,
-        )
-
-    def _string_list(self, value: Any) -> list[str]:
-        if isinstance(value, list):
-            results: list[str] = []
-            for item in value:
-                if isinstance(item, (str, int)):
-                    results.append(str(item))
-                elif isinstance(item, dict):
-                    path = item.get("path") or item.get("file") or item.get("name") or item.get("id")
-                    if path:
-                        results.append(str(path))
-            return results
-        if isinstance(value, dict):
-            if "path" in value or "file" in value:
-                return [str(value.get("path") or value.get("file"))]
-            return [str(key) for key in value.keys()]
-        return []
-
-    def _run(self, command: list[str]) -> "_RunResult":
-        try:
-            result = subprocess.run(
-                command,
-                cwd=self.project_root,
-                capture_output=True,
-                text=True,
-                encoding="utf-8",
-                errors="replace",
-                timeout=20,
-            )
-            return _RunResult(
-                returncode=result.returncode,
-                output=(result.stdout or "") + (result.stderr or ""),
-            )
-        except Exception as exc:
-            return _RunResult(returncode=1, output=str(exc))
-
-
-class _RunResult(BaseModel):
-    returncode: int
-    output: str

package/src/devcouncil/integrations/github.py

@@ -1,39 +0,0 @@
-import httpx
-import logging
-from devcouncil.artifacts.graph import ArtifactGraph
-from devcouncil.reporting.github_check import GitHubCheckGenerator
-
-logger = logging.getLogger(__name__)
-
-class GitHubIntegration:
-    """Manages interactions with GitHub API, specifically PR Checks."""
-    
-    def __init__(self, github_token: str, repository: str, commit_sha: str):
-        self.github_token = github_token
-        self.repository = repository
-        self.commit_sha = commit_sha
-        self.base_url = f"https://api.github.com/repos/{repository}"
-
-    async def report_verification(self, graph: ArtifactGraph):
-        """Creates or updates a GitHub Check Run with the current verification status."""
-        payload = GitHubCheckGenerator.generate(graph)
-        payload["head_sha"] = self.commit_sha
-        
-        headers = {
-            "Authorization": f"Bearer {self.github_token}",
-            "Accept": "application/vnd.github.v3+json",
-            "Content-Type": "application/json"
-        }
-        
-        async with httpx.AsyncClient() as client:
-            try:
-                response = await client.post(
-                    f"{self.base_url}/check-runs",
-                    headers=headers,
-                    json=payload
-                )
-                response.raise_for_status()
-                logger.info(f"GitHub PR Check updated for {self.repository} at {self.commit_sha}")
-            except Exception as e:
-                logger.error(f"Failed to report to GitHub: {e}")
-                raise

package/src/devcouncil/integrations/gitnexus.py

@@ -1,27 +0,0 @@
-from pathlib import Path
-from rich.console import Console
-from devcouncil.indexing.graph_index import GraphIndex
-
-console = Console()
-
-class GitNexusIntegration:
-    """
-    Integration for GitNexus: Codebase knowledge graph and structural awareness.
-    """
-    def __init__(self, project_root: Path):
-        self.project_root = project_root
-
-    def initialize(self):
-        console.print("[cyan]Initializing GitNexus context...[/cyan]")
-        nexus_dir = self.project_root / ".devcouncil" / "nexus"
-        nexus_dir.mkdir(exist_ok=True)
-        # Mock initialization logic
-        (nexus_dir / "index_config.json").write_text('{"mode": "structural", "version": "1.0"}')
-        console.print("  - GitNexus structural awareness active.")
-
-    def sync_graph(self, graph_index: GraphIndex):
-        """
-        Export DevCouncil artifact graph to GitNexus.
-        """
-        console.print("  - Syncing DevCouncil artifacts to GitNexus...")
-        pass

package/src/devcouncil/integrations/graphify.py

@@ -1,34 +0,0 @@
-from pathlib import Path
-from rich.console import Console
-
-console = Console()
-
-class GraphifyIntegration:
-    """
-    Integration for graphify: Always-on graph context and multi-agent integration.
-    """
-    def __init__(self, project_root: Path):
-        self.project_root = project_root
-
-    def initialize(self):
-        console.print("[magenta]Initializing Graphify engine...[/magenta]")
-        graphify_config = self.project_root / ".devcouncil" / "graphify.yaml"
-        # Create a default graphify config
-        content = """
-graph:
-  engine: internal
-  persist: true
-agents:
-  shared_context: true
-hooks:
-  enabled: true
-"""
-        graphify_config.write_text(content.strip())
-        console.print("  - Graphify engine configured and ready.")
-
-    def apply_rules(self):
-        """
-        Apply graph-based rules to implementation plans.
-        """
-        console.print("  - Graphify checking architectural rules...")
-        pass