devcouncil 0.2.0 → 0.3.1

package/src/devcouncil/indexing/ast_matcher.py

@@ -71,12 +71,13 @@ class AstMatcher:
         language: str | None = None,
         kind: str | None = None,
         limit: int = 100,
+        files: list[Path] | None = None,
     ) -> list[AstMatch]:
         language = language.lower() if language else None
         kind = kind.lower() if kind else None
         limit = max(1, limit)
         matches: list[AstMatch] = []
-        for path in self._candidate_files(language):
+        for path in self._candidate_files(language, files):
             try:
                 text = path.read_text(encoding="utf-8")
             except (OSError, UnicodeDecodeError):
@@ -88,22 +89,31 @@ class AstMatcher:
                 return matches[:limit]
         return matches[:limit]
 
-    def _candidate_files(self, language: str | None) -> list[Path]:
+    def _candidate_files(self, language: str | None, files: list[Path] | None = None) -> list[Path]:
         allowed_exts = {
             ext for ext, ext_language in self._EXT_LANGUAGE.items()
             if language is None or ext_language == language
         }
-        files: list[Path] = []
+        # When the caller already walked the tree (e.g. SemanticIndex.create_snapshot
+        # shares one traversal across all collectors), filter that list in memory
+        # instead of re-globbing. The filter is identical to the rglob path below.
+        if files is not None:
+            return sorted(
+                path for path in files
+                if path.is_file() and path.suffix.lower() in allowed_exts
+                and not any(part in self._IGNORED_DIRS for part in path.parts)
+            )
+        candidates: list[Path] = []
         try:
             for path in self.project_root.rglob("*"):
                 if not path.is_file() or path.suffix.lower() not in allowed_exts:
                     continue
                 if any(part in self._IGNORED_DIRS for part in path.parts):
                     continue
-                files.append(path)
+                candidates.append(path)
         except OSError:
-            return files
-        return sorted(files)
+            return candidates
+        return sorted(candidates)
 
     def _match_file(self, rel: str, language: str, text: str, *, query: str, kind: str | None) -> list[AstMatch]:
         if language == "python":

package/src/devcouncil/indexing/repo_mapper.py

@@ -78,6 +78,15 @@ class RepoMapper:
         # Import edges (importer -> imported), computed once per map_repo run and reused
         # by subsystem inference, important-file ranking, and the dependents index.
         self._edges: List[Tuple[str, str]] | None = None
+        # Cache of config-file contents (package.json, pyproject.toml, ...) so framework
+        # and test-command detection don't each re-read the same files from disk.
+        self._config_file_cache: Dict[str, str] = {}
+
+    def _read_config_file(self, name: str) -> str:
+        """Read a repo-root config file once and cache its contents for reuse."""
+        if name not in self._config_file_cache:
+            self._config_file_cache[name] = (self.project_root / name).read_text()
+        return self._config_file_cache[name]
 
     _DEPENDENTS_MAX = 12  # cap dependents listed per file to bound repo_map.json size
 
@@ -768,12 +777,24 @@ class RepoMapper:
 
     def _build_hardcoded_subsystems(self, files: List[str]) -> List[RepoSubsystem]:
         file_set = set(files)
+        # Single O(n) pass: bucket files by their "src/devcouncil/<area>" prefix so the
+        # per-subsystem loop below uses O(1) dict lookups instead of rescanning every
+        # file for each area (and, previously, again for each neighbor). All subsystem
+        # and neighbor keys are 3-component "src/devcouncil/<area>" prefixes, so this
+        # bucketing reproduces the prior `path.startswith(f"{area}/")` semantics exactly.
+        by_area: Dict[str, List[str]] = {}
+        for path in files:
+            parts = path.split("/")
+            if len(parts) >= 4 and parts[0] == "src" and parts[1] == "devcouncil":
+                by_area.setdefault("/".join(parts[:3]), []).append(path)
+        for bucket in by_area.values():
+            bucket.sort()
         subsystems: List[RepoSubsystem] = []
         for area, (summary, entry_points) in self._SUBSYSTEM_INDEX.items():
             available_entry_points = [path for path in entry_points if path in file_set]
             if not available_entry_points:
                 continue
-            area_files = sorted(path for path in files if path.startswith(f"{area}/"))
+            area_files = by_area.get(area, [])
             ranked_files = [path for path in available_entry_points if path in file_set]
             for path in area_files:
                 if path in available_entry_points:
@@ -782,7 +803,7 @@ class RepoMapper:
                     break
                 ranked_files.append(path)
             critical_files = ranked_files[: self._SUBSYSTEM_CRITICAL_MAX]
-            neighbors = [n for n in self._SUBSYSTEM_NEIGHBORS.get(area, []) if any(f.startswith(f"{n}/") for f in files)]
+            neighbors = [n for n in self._SUBSYSTEM_NEIGHBORS.get(area, []) if n in by_area]
             handoff_paths = self._SUBSYSTEM_HANDOFFS.get(area, [])
             role_files = self._build_role_files(area, area_files)
             subsystems.append(
@@ -1262,7 +1283,7 @@ class RepoMapper:
         frameworks = []
         file_set = set(files)
         if "package.json" in file_set:
-            content = (self.project_root / "package.json").read_text()
+            content = self._read_config_file("package.json")
             if "next" in content:
                 frameworks.append("nextjs")
             if "react" in content:
@@ -1274,12 +1295,13 @@ class RepoMapper:
         
         if "requirements.txt" in file_set or "pyproject.toml" in file_set:
             try:
-                content = ""
+                parts: List[str] = []
                 if "requirements.txt" in file_set:
-                    content += (self.project_root / "requirements.txt").read_text()
+                    parts.append(self._read_config_file("requirements.txt"))
                 if "pyproject.toml" in file_set:
-                    content += (self.project_root / "pyproject.toml").read_text()
-                
+                    parts.append(self._read_config_file("pyproject.toml"))
+                content = "".join(parts)
+
                 if "fastapi" in content.lower():
                     frameworks.append("fastapi")
                 if "flask" in content.lower():
@@ -1317,7 +1339,7 @@ class RepoMapper:
         # 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())
+                pkg = json.loads(self._read_config_file("package.json"))
                 scripts = pkg.get("scripts", {})
                 pm = "pnpm" if "pnpm-lock.yaml" in file_set else (
                     "yarn" if "yarn.lock" in file_set else "npm"

package/src/devcouncil/indexing/semantic_index.py

@@ -34,17 +34,25 @@ class SemanticIndex:
         return self.semantic_dir / task_id / f"{stage}.json"
 
     def create_snapshot(self, task_id: str, stage: str) -> Path:
-        symbols = self._collect_symbols()
+        # Walk the tree ONCE and share the file list across every collector. Previously
+        # create_snapshot triggered four independent full-tree rglob() traversals (symbol
+        # matching, source-file hashing, import extraction, and LSP language detection);
+        # each collector now filters this single in-memory list with its own predicate, so
+        # the on-disk output is unchanged while the filesystem is walked a single time.
+        all_files = [path for path in self.project_root.rglob("*") if path.is_file()]
+        rel_files = [str(path.relative_to(self.project_root)) for path in all_files]
+        symbols = self._collect_symbols(all_files)
+        source_files, imports = self._collect_source_data(all_files)
         payload = {
             "task_id": task_id,
             "created_at": datetime.now(timezone.utc).isoformat(),
             "repo_map_path": str(self.project_root / ".devcouncil" / "repo_map.json"),
             "files": self._config_file_entries(),
-            "source_files": self._source_file_entries(),
+            "source_files": source_files,
             "symbols": symbols,
-            "imports": self._collect_imports(),
+            "imports": imports,
             "public_symbols": [s for s in symbols if s.get("public")],
-            "lsp": json.loads(LspInspector(self.project_root).summary_json()),
+            "lsp": json.loads(LspInspector(self.project_root).summary_json(rel_files)),
         }
         path = self.snapshot_path(task_id, stage)
         path.parent.mkdir(parents=True, exist_ok=True)
@@ -72,9 +80,9 @@ class SemanticIndex:
                 )
         return {"classifications": classifications, "summary": summary}
 
-    def _collect_symbols(self) -> list[dict]:
+    def _collect_symbols(self, files: list[Path] | None = None) -> list[dict]:
         symbols: list[dict] = []
-        for match in self.matcher.match(limit=500):
+        for match in self.matcher.match(limit=500, files=files):
             symbols.append({
                 "path": match.path,
                 "language": match.language,
@@ -86,19 +94,39 @@ class SemanticIndex:
             })
         return symbols
 
-    def _collect_imports(self) -> list[dict]:
+    def _collect_source_data(
+        self, files: list[Path] | None = None
+    ) -> tuple[list[dict], list[dict]]:
+        """Hash every source file and extract its imports in a SINGLE read pass.
+
+        Previously ``_source_file_entries`` read every source file's bytes for hashing
+        while ``_collect_imports`` independently re-read (and, for Python, re-parsed) the
+        same files. This reads each file once: the raw bytes feed the SHA-256 entry, and
+        the decoded text feeds import extraction. The import set is a subset of the hashed
+        set (it additionally skips dot-prefixed paths), so both outputs match the originals
+        exactly — source entries are still sorted by path, imports stay in traversal order.
+        """
+        if files is None:
+            files = [p for p in self.project_root.rglob("*") if p.is_file()]
+        source_entries: list[dict] = []
         imports: list[dict] = []
-        for path in self.project_root.rglob("*"):
+        for path in files:
             if not path.is_file() or path.suffix not in {".py", ".ts", ".tsx", ".js", ".go", ".rs"}:
                 continue
             rel = path.relative_to(self.project_root).as_posix()
-            # Filter on the path relative to the project root — filtering on the
-            # absolute path would skip everything when the repo itself lives
-            # under a dot-directory.
+            if self._is_ignored_path(rel):
+                continue
+            raw = path.read_bytes()
+            source_entries.append({"path": rel, "sha256": hashlib.sha256(raw).hexdigest()})
+            # Imports additionally skip dot-prefixed relative paths. Filter on the path
+            # relative to the project root — filtering on the absolute path would skip
+            # everything when the repo itself lives under a dot-directory.
             rel_parts = Path(rel).parts
-            if self._is_ignored_path(rel) or any(part.startswith(".") for part in rel_parts):
+            if any(part.startswith(".") for part in rel_parts):
                 continue
-            source = path.read_text(encoding="utf-8", errors="replace")
+            # Decode the bytes we already read, normalizing newlines the same way
+            # Path.read_text(newline=None) did, so parsed import statements are identical.
+            source = raw.decode("utf-8", errors="replace").replace("\r\n", "\n").replace("\r", "\n")
             if path.suffix == ".py":
                 try:
                     tree = ast.parse(source)
@@ -112,7 +140,7 @@ class SemanticIndex:
                 for line in source.splitlines():
                     if re.match(r"^\s*(import|from)\s+", line):
                         imports.append({"path": rel, "statement": line.strip()})
-        return imports
+        return sorted(source_entries, key=lambda item: item["path"]), imports
 
     def _classify(self, before: dict, after: dict) -> list[dict]:
         before_symbols = {(s["path"], s["name"]): s for s in before.get("symbols", [])}
@@ -188,18 +216,6 @@ class SemanticIndex:
                 })
         return entries
 
-    def _source_file_entries(self) -> list[dict]:
-        entries: list[dict] = []
-        for path in self.project_root.rglob("*"):
-            if not path.is_file() or path.suffix not in {".py", ".ts", ".tsx", ".js", ".go", ".rs"}:
-                continue
-            rel = path.relative_to(self.project_root).as_posix()
-            if self._is_ignored_path(rel):
-                continue
-            raw = path.read_bytes()
-            entries.append({"path": rel, "sha256": hashlib.sha256(raw).hexdigest()})
-        return sorted(entries, key=lambda item: item["path"])
-
     def _is_ignored_path(self, rel_path: str) -> bool:
         ignored_parts = {".git", ".devcouncil", "__pycache__", ".venv", "node_modules", "dist", "build", "target", "vendor"}
         return any(part in ignored_parts for part in Path(rel_path).parts)

package/src/devcouncil/integrations/actions.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import json
+import logging
 import shutil
 from dataclasses import dataclass
 from pathlib import Path
@@ -8,6 +9,8 @@ from typing import Any
 
 from devcouncil.integrations.check import build_integration_check_report
 
+logger = logging.getLogger(__name__)
+
 VALID_INTEGRATION_TARGETS = {
     "all",
     "hooks",
@@ -65,15 +68,18 @@ def apply_integration_target(
     strict: bool = False,
     gemini_scope: str = "project",
     claude_scope: str = "local",
+    claude_write_gate: bool = False,
 ) -> IntegrationActionReport:
     from devcouncil.cli.commands import integrate
 
     root = project_root.expanduser().resolve()
     normalized = normalize_apply_target(target)
+    logger.info("Applying integration target: %s (root=%s)", normalized, root)
     warnings: list[str] = []
     results: list[dict[str, Any]] = []
 
     def add_result(name: str, ok: bool, path: Path | None = None, message: str = "") -> None:
+        (logger.info if ok else logger.warning)("Integration %s: %s — %s", name, "ok" if ok else "FAILED", message)
         results.append({
             "target": name,
             "ok": ok,
@@ -119,19 +125,33 @@ def apply_integration_target(
         add_result("aider", True, root / ".devcouncil" / "config.yaml", "Aider executor enabled.")
 
     def apply_hooks() -> None:
-        integrate._configure_native_hooks(root, "all", apply=True)
+        integrate._configure_native_hooks(root, "all", apply=True, claude_write_gate=claude_write_gate)
         add_result("hooks", True, None, "Native hook files configured.")
 
+    def apply_claude_assets() -> None:
+        try:
+            written = integrate._install_claude_assets(root)
+        except (ValueError, FileNotFoundError, OSError) as exc:
+            add_result("claude-assets", False, None, f"Claude asset setup failed: {exc}")
+            return
+        add_result("claude-assets", True, None, f"Claude assets installed ({len(written)} file(s)).")
+
     if normalized == "all":
         for name in ("codex", "gemini", "claude"):
             apply_first_party(name)
-        # Batch the per-tool config.yaml record updates into one load/save.
+        # Batch the per-tool config.yaml record updates (project files, aider,
+        # and native hooks) into one load/save cycle. _batched_raw_config is
+        # re-entrant, so apply_hooks()'s own batching participates in this one.
         with integrate._batched_raw_config(root):
             for name in ("cursor", "opencode", "antigravity", "warp"):
                 apply_project_file(name)
             apply_aider()
-        if include_hooks:
-            apply_hooks()
+            if include_hooks:
+                apply_hooks()
+            # The static Claude Code asset surface (slash commands, subagents, output
+            # style, statusline, permissions, skills) — installed regardless of whether
+            # the claude CLI is on PATH, since these are plain files.
+            apply_claude_assets()
     elif normalized in {"codex", "gemini", "claude"}:
         apply_first_party(normalized)
     elif normalized in {"cursor", "opencode", "antigravity", "warp"}:

package/src/devcouncil/integrations/check.py

@@ -107,8 +107,11 @@ def probe_coding_cli_version(client: str) -> tuple[bool, str]:
     return False, f"Optional; install {label} to use this integration."
 
 
-def recommended_executor_status(project_root: Path) -> tuple[bool, str]:
-    detected = detect_available_coding_cli(project_root)
+def recommended_executor_status(
+    project_root: Path, detected: str | None = None
+) -> tuple[bool, str]:
+    if detected is None:
+        detected = detect_available_coding_cli(project_root)
     if not detected:
         return False, "No built-in coding CLI on PATH. Run dev integrate recommend after installing one."
     resolved = resolve_automated_executor(project_root, None)
@@ -279,6 +282,7 @@ def build_integration_check_report(project_root: Path, *, strict: bool = False)
         rows.append(IntegrationCheckRow(name=name, status="skip", details=details))
 
     root = project_root.expanduser().resolve()
+    detected = detect_available_coding_cli(root)
     add((root / ".devcouncil").exists(), "Project state", str(root / ".devcouncil"))
     devcouncil_path = shutil.which("devcouncil")
     add(
@@ -295,7 +299,7 @@ def build_integration_check_report(project_root: Path, *, strict: bool = False)
         cli_ok, cli_details = probe_coding_cli_version(client)
         add_optional(cli_ok, CODING_CLI_CHECK_LABELS.get(client, client), cli_details)
 
-    rec_ok, rec_details = recommended_executor_status(root)
+    rec_ok, rec_details = recommended_executor_status(root, detected)
     add_optional(rec_ok, "Recommended coding CLI", rec_details)
 
     for row in integration_capability_rows(root):
@@ -383,7 +387,6 @@ def build_integration_check_report(project_root: Path, *, strict: bool = False)
             str(hook_path) if references else f"{hook_path} no longer references devcouncil (tampered/disarmed).",
         )
 
-    detected = detect_available_coding_cli(root)
     recommended = resolve_automated_executor(root, None) if detected else None
     return IntegrationCheckReport(tuple(rows), recommended, failures)