Add dependency extractors for 8 new languages + test_project.py

Dependency extractors (test_mapper.py):
- C#: using statements (using System; using MyApp.Models;)
- Java/Kotlin: import statements (import com.myapp.Calculator;)
- C/C++: #include directives (#include <gtest/gtest.h>)
- Swift: import statements (import XCTest)
- PHP: use statements + require/include (use App\Models\User;)
- Ruby: require/require_relative (require 'rspec')
- Dart: import statements (import 'package:myapp/utils.dart';)

Previously these 8 languages had test file discovery and parsing but
zero dependency extraction — meaning impact, suggest_tests, and
diff_impact were blind to their test coverage. Now test-to-code edges
are built for all 12 supported languages.

Tests:
- test_project.py: 14 tests covering detect_project_root (git repo,
  subdir, non-git), normalize_path (absolute, relative, dot-slash,
  parent refs), resolve_storage_dir (priority chain: explicit > env >
  project-local > home), ProcessLock (exclusive, shared, nested shared,
  directory creation, release on exception)
- test_test_mapper.py: 11 new tests for all 8 language extractors
  including edge cases (Java wildcard imports skipped)

450 tests pass, ruff clean.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: IronAdamant

chisel/test_mapper.py

@@ -151,6 +151,20 @@ def extract_test_dependencies(self, file_path, content):
             return _extract_go_deps(content)
         if lang == "rust":
             return _extract_rust_deps(content)
+        if lang == "csharp":
+            return _extract_csharp_deps(content)
+        if lang == "java" or lang == "kotlin":
+            return _extract_java_deps(content)
+        if lang in ("c", "cpp"):
+            return _extract_cpp_deps(content)
+        if lang == "swift":
+            return _extract_swift_deps(content)
+        if lang == "php":
+            return _extract_php_deps(content)
+        if lang == "ruby":
+            return _extract_ruby_deps(content)
+        if lang == "dart":
+            return _extract_dart_deps(content)
         return []
 
     # ------------------------------------------------------------------ #
@@ -423,6 +437,135 @@ def _extract_rust_deps(content):
     return _dedupe_deps(deps)
 
 
+# ------------------------------------------------------------------ #
+# C# dependency extraction
+# ------------------------------------------------------------------ #
+
+_CS_USING_RE = re.compile(r"^\s*using\s+(?:static\s+)?([A-Za-z_][\w.]*)\s*;", re.MULTILINE)
+
+
+def _extract_csharp_deps(content):
+    """Extract using statements from C# content."""
+    deps = []
+    for m in _CS_USING_RE.finditer(content):
+        name = m.group(1).rsplit(".", 1)[-1]
+        deps.append({"name": name, "dep_type": "import"})
+    return _dedupe_deps(deps)
+
+
+# ------------------------------------------------------------------ #
+# Java / Kotlin dependency extraction
+# ------------------------------------------------------------------ #
+
+_JAVA_IMPORT_RE = re.compile(r"^\s*import\s+(?:static\s+)?([A-Za-z_][\w.]*)\s*;?", re.MULTILINE)
+
+
+def _extract_java_deps(content):
+    """Extract import statements from Java/Kotlin content."""
+    deps = []
+    for m in _JAVA_IMPORT_RE.finditer(content):
+        name = m.group(1).rsplit(".", 1)[-1]
+        if name != "*":
+            deps.append({"name": name, "dep_type": "import"})
+    return _dedupe_deps(deps)
+
+
+# ------------------------------------------------------------------ #
+# C / C++ dependency extraction
+# ------------------------------------------------------------------ #
+
+_CPP_INCLUDE_RE = re.compile(r'^\s*#\s*include\s*[<"]([^>"]+)[>"]', re.MULTILINE)
+
+
+def _extract_cpp_deps(content):
+    """Extract #include directives from C/C++ content."""
+    deps = []
+    for m in _CPP_INCLUDE_RE.finditer(content):
+        header = m.group(1)
+        # Extract base name: "mylib/utils.h" -> "utils"
+        name = header.rsplit("/", 1)[-1].split(".")[0]
+        deps.append({"name": name, "dep_type": "import"})
+    return _dedupe_deps(deps)
+
+
+# ------------------------------------------------------------------ #
+# Swift dependency extraction
+# ------------------------------------------------------------------ #
+
+_SWIFT_IMPORT_RE = re.compile(r"^\s*import\s+(\w+)", re.MULTILINE)
+
+
+def _extract_swift_deps(content):
+    """Extract import statements from Swift content."""
+    deps = []
+    for m in _SWIFT_IMPORT_RE.finditer(content):
+        deps.append({"name": m.group(1), "dep_type": "import"})
+    return _dedupe_deps(deps)
+
+
+# ------------------------------------------------------------------ #
+# PHP dependency extraction
+# ------------------------------------------------------------------ #
+
+_PHP_USE_RE = re.compile(r"^\s*use\s+([A-Za-z_][\w\\]*)\s*;", re.MULTILINE)
+_PHP_REQUIRE_RE = re.compile(
+    r"(?:require|require_once|include|include_once)\s*\(?\s*['\"]([^'\"]+)['\"]\s*\)?",
+    re.MULTILINE,
+)
+
+
+def _extract_php_deps(content):
+    """Extract use statements and require/include from PHP content."""
+    deps = []
+    for m in _PHP_USE_RE.finditer(content):
+        name = m.group(1).rsplit("\\", 1)[-1]
+        deps.append({"name": name, "dep_type": "import"})
+    for m in _PHP_REQUIRE_RE.finditer(content):
+        path = m.group(1)
+        name = path.rsplit("/", 1)[-1].split(".")[0]
+        deps.append({"name": name, "dep_type": "import"})
+    return _dedupe_deps(deps)
+
+
+# ------------------------------------------------------------------ #
+# Ruby dependency extraction
+# ------------------------------------------------------------------ #
+
+_RB_REQUIRE_RE = re.compile(r"^\s*require(?:_relative)?\s+['\"]([^'\"]+)['\"]", re.MULTILINE)
+
+
+def _extract_ruby_deps(content):
+    """Extract require/require_relative from Ruby content."""
+    deps = []
+    for m in _RB_REQUIRE_RE.finditer(content):
+        path = m.group(1)
+        name = path.rsplit("/", 1)[-1]
+        deps.append({"name": name, "dep_type": "import"})
+    return _dedupe_deps(deps)
+
+
+# ------------------------------------------------------------------ #
+# Dart dependency extraction
+# ------------------------------------------------------------------ #
+
+_DART_IMPORT_RE = re.compile(r"^\s*import\s+['\"]([^'\"]+)['\"]", re.MULTILINE)
+
+
+def _extract_dart_deps(content):
+    """Extract import statements from Dart content."""
+    deps = []
+    for m in _DART_IMPORT_RE.finditer(content):
+        path = m.group(1)
+        # "package:myapp/utils.dart" -> "utils"
+        name = path.rsplit("/", 1)[-1].split(".")[0]
+        deps.append({"name": name, "dep_type": "import"})
+    return _dedupe_deps(deps)
+
+
+# ------------------------------------------------------------------ #
+# Shared utility
+# ------------------------------------------------------------------ #
+
 def _dedupe_deps(deps):
     """Remove duplicate dependencies, keeping first occurrence."""
     seen = set()

tests/test_project.py

@@ -0,0 +1,163 @@
+"""Tests for chisel.project — multi-agent safety utilities."""
+
+import os
+import subprocess
+
+import pytest
+
+from chisel.project import (
+    ProcessLock,
+    detect_project_root,
+    normalize_path,
+    resolve_storage_dir,
+)
+
+
+# ------------------------------------------------------------------ #
+# detect_project_root
+# ------------------------------------------------------------------ #
+
+class TestDetectProjectRoot:
+    def test_finds_current_repo(self):
+        """Running inside the Chisel repo should find its root."""
+        root = detect_project_root()
+        assert os.path.isdir(root)
+        assert os.path.isfile(os.path.join(root, "pyproject.toml"))
+
+    def test_finds_root_from_subdirectory(self, tmp_path):
+        """Should walk up from a subdir to find the git root."""
+        repo = tmp_path / "repo"
+        repo.mkdir()
+        subprocess.run(["git", "init"], cwd=str(repo), capture_output=True)
+        subdir = repo / "a" / "b" / "c"
+        subdir.mkdir(parents=True)
+        root = detect_project_root(str(subdir))
+        assert os.path.samefile(root, str(repo))
+
+    def test_non_git_dir_returns_start(self, tmp_path):
+        """A dir with no .git should return itself."""
+        plain = tmp_path / "plain"
+        plain.mkdir()
+        root = detect_project_root(str(plain))
+        assert os.path.samefile(root, str(plain))
+
+    def test_defaults_to_cwd(self):
+        """With no args, should use cwd."""
+        root = detect_project_root()
+        assert os.path.isabs(root)
+
+    def test_returns_absolute_path(self, tmp_path):
+        repo = tmp_path / "repo"
+        repo.mkdir()
+        subprocess.run(["git", "init"], cwd=str(repo), capture_output=True)
+        root = detect_project_root(str(repo))
+        assert os.path.isabs(root)
+
+
+# ------------------------------------------------------------------ #
+# normalize_path
+# ------------------------------------------------------------------ #
+
+class TestNormalizePath:
+    def test_absolute_path_becomes_relative(self):
+        root = "/home/user/project"
+        result = normalize_path("/home/user/project/src/main.py", root)
+        assert result == "src/main.py"
+
+    def test_relative_path_unchanged(self):
+        result = normalize_path("src/main.py", "/any/root")
+        assert result == "src/main.py"
+
+    def test_dot_slash_stripped(self):
+        result = normalize_path("./src/main.py", "/any/root")
+        assert result == "src/main.py"
+
+    def test_parent_refs_normalized(self):
+        result = normalize_path("src/../lib/utils.py", "/any/root")
+        assert result == "lib/utils.py"
+
+    def test_already_clean_path_unchanged(self):
+        result = normalize_path("chisel/engine.py", "/any/root")
+        assert result == "chisel/engine.py"
+
+    def test_plain_filename(self):
+        result = normalize_path("README.md", "/any/root")
+        assert result == "README.md"
+
+
+# ------------------------------------------------------------------ #
+# resolve_storage_dir
+# ------------------------------------------------------------------ #
+
+class TestResolveStorageDir:
+    def test_explicit_dir_wins(self, tmp_path):
+        explicit = str(tmp_path / "custom")
+        result = resolve_storage_dir(project_dir="/any", explicit_dir=explicit)
+        assert result == explicit
+
+    def test_env_var_second_priority(self, tmp_path, monkeypatch):
+        env_dir = str(tmp_path / "env_storage")
+        monkeypatch.setenv("CHISEL_STORAGE_DIR", env_dir)
+        result = resolve_storage_dir(project_dir="/any")
+        assert result == env_dir
+
+    def test_project_local_third_priority(self, tmp_path, monkeypatch):
+        monkeypatch.delenv("CHISEL_STORAGE_DIR", raising=False)
+        repo = tmp_path / "repo"
+        repo.mkdir()
+        subprocess.run(["git", "init"], cwd=str(repo), capture_output=True)
+        result = resolve_storage_dir(project_dir=str(repo))
+        assert result.endswith(".chisel")
+        # Should be under the repo root
+        assert str(repo) in result
+
+    def test_fallback_to_home(self, monkeypatch):
+        monkeypatch.delenv("CHISEL_STORAGE_DIR", raising=False)
+        result = resolve_storage_dir(project_dir=None)
+        assert result == os.path.join(os.path.expanduser("~"), ".chisel")
+
+    def test_explicit_overrides_env(self, tmp_path, monkeypatch):
+        monkeypatch.setenv("CHISEL_STORAGE_DIR", "/should/be/ignored")
+        explicit = str(tmp_path / "winner")
+        result = resolve_storage_dir(project_dir="/any", explicit_dir=explicit)
+        assert result == explicit
+
+
+# ------------------------------------------------------------------ #
+# ProcessLock
+# ------------------------------------------------------------------ #
+
+class TestProcessLock:
+    def test_exclusive_lock_context(self, tmp_path):
+        lock = ProcessLock(str(tmp_path))
+        with lock.exclusive():
+            # Lock file should exist during the context
+            assert os.path.isfile(os.path.join(str(tmp_path), "chisel.lock"))
+
+    def test_shared_lock_context(self, tmp_path):
+        lock = ProcessLock(str(tmp_path))
+        with lock.shared():
+            assert os.path.isfile(os.path.join(str(tmp_path), "chisel.lock"))
+
+    def test_multiple_shared_locks(self, tmp_path):
+        """Multiple shared locks should not block each other."""
+        lock = ProcessLock(str(tmp_path))
+        with lock.shared():
+            with lock.shared():
+                pass  # Should not deadlock
+
+    def test_lock_creates_directory(self, tmp_path):
+        lock_dir = str(tmp_path / "nested" / "lock" / "dir")
+        lock = ProcessLock(lock_dir)
+        assert os.path.isdir(lock_dir)
+        with lock.exclusive():
+            pass
+
+    def test_lock_releases_on_exception(self, tmp_path):
+        lock = ProcessLock(str(tmp_path))
+        with pytest.raises(ValueError):
+            with lock.exclusive():
+                raise ValueError("test")
+        # Should be able to acquire again
+        with lock.exclusive():
+            pass