vigil-codeintel 0.1.0__py3-none-any.whl

vigil_forensic/source_analysis.py

@@ -0,0 +1,175 @@
+"""Shared source analysis facade for vigil_forensic.
+
+Adapted from the Vigil autoforensics source_analysis.
+Key change: uses vigil_mapper.source_adapters (sibling standalone pkg)
+instead of the Vigil autoforensics map_builder.source_adapters.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+from vigil_forensic.language_profiles import get_profile_for_extension
+from vigil_mapper.source_adapters import get_adapter_for_file
+import logging
+_log = logging.getLogger(__name__)
+
+__all__ = [
+    "FunctionInfo",
+    "is_source_file",
+    "is_test_file",
+    "get_language_id",
+    "get_generic_stems",
+    "get_shared_families",
+    "get_flow_markers",
+    "get_exclude_dirs",
+    "extract_functions",
+]
+
+
+@dataclass(frozen=True)
+class FunctionInfo:
+    """Lightweight descriptor for a function-like region in a source file."""
+    name: str
+    start_line: int
+    end_line: int
+    line_count: int
+    is_method: bool = False
+
+
+def is_source_file(path: str) -> bool:
+    """True if *path* has a known source extension (via source_adapters)."""
+    try:
+        return get_adapter_for_file(Path(path)) is not None
+    except Exception:
+        _log.debug("is_source_file: adapter lookup failed for %r", path)
+        return False
+
+
+def is_test_file(path: str) -> bool:
+    """True if *path* matches test file patterns for its language."""
+    p = Path(path)
+    ext = p.suffix.lower()
+    profile = get_profile_for_extension(ext)
+    if profile is None:
+        return False
+    name = p.name
+    path_str = path.replace("\\", "/")
+    return any(
+        name.startswith(pat) or name.endswith(pat) or pat in path_str
+        for pat in profile.test_file_patterns
+    )
+
+
+def get_language_id(path: str) -> str | None:
+    """Return the language_id for *path*, or None if unsupported."""
+    ext = Path(path).suffix.lower()
+    profile = get_profile_for_extension(ext)
+    return profile.language_id if profile else None
+
+
+def get_generic_stems(path: str) -> frozenset[str]:
+    ext = Path(path).suffix.lower()
+    profile = get_profile_for_extension(ext)
+    return profile.generic_helper_stems if profile else frozenset()
+
+
+def get_shared_families(path: str) -> frozenset[str]:
+    ext = Path(path).suffix.lower()
+    profile = get_profile_for_extension(ext)
+    return profile.shared_layer_families if profile else frozenset()
+
+
+def get_flow_markers(path: str) -> tuple[str, ...]:
+    ext = Path(path).suffix.lower()
+    profile = get_profile_for_extension(ext)
+    return profile.flow_marker_patterns if profile else ()
+
+
+def get_exclude_dirs(path: str) -> frozenset[str]:
+    ext = Path(path).suffix.lower()
+    profile = get_profile_for_extension(ext)
+    return profile.exclude_dir_hints if profile else frozenset()
+
+
+def extract_functions(path: str, content: str) -> list[FunctionInfo]:
+    """Extract function-like regions from *content*. Never raises; returns [] on error."""
+    lang = get_language_id(path)
+    if lang == "python":
+        return _extract_python_functions(content)
+    if lang in ("javascript", "typescript"):
+        return _extract_js_functions(content)
+    return []
+
+
+def _extract_python_functions(content: str) -> list[FunctionInfo]:
+    try:
+        from vigil_forensic.gate_checks.common import extract_python_functions as _ast_extract
+        raw = _ast_extract(content)
+        return [
+            FunctionInfo(name=name, start_line=start, end_line=end, line_count=end - start + 1, is_method=False)
+            for name, start, end, snippet in raw
+        ]
+    except Exception as exc:
+        _log.debug("_extract_python_functions failed: %s", exc)
+        return []
+
+
+_JS_FUNCTION_RE = re.compile(
+    r"""
+    (?:^|\s)
+    (?:
+        (?:async\s+)?function\s+
+        (?P<fn_name>[A-Za-z_$][A-Za-z0-9_$]*)
+        \s*\(
+    |
+        (?P<arrow_name>[A-Za-z_$][A-Za-z0-9_$]*)
+        \s*=\s*
+        (?:async\s+)?
+        \(.*?\)\s*=>
+    |
+        ^\s*
+        (?P<method_name>[A-Za-z_$][A-Za-z0-9_$]*)
+        \s*\(
+    )
+    """,
+    re.VERBOSE | re.MULTILINE,
+)
+
+
+def _extract_js_functions(content: str) -> list[FunctionInfo]:
+    try:
+        lines = content.splitlines()
+        results: list[FunctionInfo] = []
+        for i, line in enumerate(lines, start=1):
+            stripped = line.strip()
+            m = re.match(r"(?:async\s+)?function\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*\(", stripped)
+            if m:
+                name = m.group(1)
+                end_line = min(i + 9, len(lines))
+                results.append(FunctionInfo(name=name, start_line=i, end_line=end_line, line_count=end_line - i + 1))
+                continue
+            m = re.match(
+                r"(?:const|let|var)\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*(?:async\s*)?\(.*?\)\s*=>",
+                stripped,
+            )
+            if m:
+                name = m.group(1)
+                end_line = min(i + 9, len(lines))
+                results.append(FunctionInfo(name=name, start_line=i, end_line=end_line, line_count=end_line - i + 1))
+                continue
+            m = re.match(r"([A-Za-z_$][A-Za-z0-9_$]*)\s*\(", stripped)
+            if m and not re.match(
+                r"^(?:if|for|while|switch|catch|return|import|export|class|const|let|var)\b", stripped,
+            ):
+                if line and line[0] in (" ", "\t"):
+                    name = m.group(1)
+                    end_line = min(i + 9, len(lines))
+                    results.append(FunctionInfo(
+                        name=name, start_line=i, end_line=end_line,
+                        line_count=end_line - i + 1, is_method=True,
+                    ))
+        return results
+    except Exception:
+        return []

vigil_mapper/__init__.py

@@ -0,0 +1,103 @@
+"""Public API for the map builder subsystem.
+
+Deferred (lazy) imports only -- avoids circular import chains during
+early startup before map_models/map_storage are fully initialised.
+
+Public surface:
+    build_all_maps(project_dir)  -- stub, implemented in Phase 7 (cli_entry.py)
+    load_repo_maps(project_dir)  -- load all 7 maps from disk
+    maps_dir(project_dir)        -- default output dir: <project_dir>/.cortex/maps/
+    seeds_dir(project_dir)       -- default seeds dir: <project_dir>/.cortex/map_seeds/
+    RepoMaps                     -- container dataclass
+"""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .map_models import RepoMaps as _RepoMaps
+
+__all__ = [
+    "build_all_maps",
+    "load_repo_maps",
+    "maps_dir",
+    "run_map_build",
+    "seeds_dir",
+    "RepoMaps",
+]
+
+
+def load_repo_maps(project_dir: Path):
+    """Load all 7 maps from <project_dir>/.cortex/maps/. Deferred import."""
+    from .map_storage import load_repo_maps as _load  # noqa: PLC0415
+    return _load(project_dir)
+
+
+def maps_dir(project_dir: Path) -> Path:
+    """Default output location: <project_dir>/.cortex/maps/. Deferred import."""
+    from .map_storage import maps_dir as _maps_dir  # noqa: PLC0415
+    return _maps_dir(project_dir)
+
+
+def seeds_dir(project_dir: Path) -> Path:
+    """Default seed config location: <project_dir>/.cortex/map_seeds/. Deferred import."""
+    from .map_storage import seeds_dir as _seeds_dir  # noqa: PLC0415
+    return _seeds_dir(project_dir)
+
+
+def build_all_maps(project_dir: Path) -> None:
+    """Build all maps (stub -- full implementation in Phase 7 cli_entry.py).
+
+    Currently raises NotImplementedError so callers discover the gap early.
+    """
+    raise NotImplementedError(
+        "build_all_maps is not implemented yet. "
+        "Use run_map_build(project_dir) or the vigil-mapper-mcp server instead."
+    )
+
+
+def run_map_build(
+    project_dir,
+    *,
+    map: str = "all",
+    dry_run: bool = False,
+    strict: bool = False,
+    timeout_s: int = 300,
+    output_dir=None,
+    max_file_mb: float = 5.0,
+    cancel_event=None,
+) -> int:
+    """Programmatic API for the map build pipeline. Deferred import.
+
+    Args:
+        project_dir: Absolute (or resolvable) path to the target project root.
+        map: Map name to build, or "all" for the full pipeline.
+        dry_run: If True, build all maps in memory but do not write to disk.
+        strict: If True, return exit code 3 on warnings, 4 on new conflicts.
+        timeout_s: Timeout in seconds for the tracer (runtime map only).
+        output_dir: If given, writes maps here instead of <project_dir>/.cortex/maps/.
+        max_file_mb: Files larger than this threshold (MiB) are skipped.
+            Default: 5.0 MiB.  Pass float('inf') to disable.
+        cancel_event: Optional threading.Event; build stops early when set.
+
+    See ``vigil_mapper.cli_entry.run_map_build`` for full docs.
+    """
+    from .cli_entry import run_map_build as _run  # noqa: PLC0415
+    return _run(
+        project_dir,
+        map=map,
+        dry_run=dry_run,
+        strict=strict,
+        timeout_s=timeout_s,
+        output_dir=output_dir,
+        max_file_mb=max_file_mb,
+        cancel_event=cancel_event,
+    )
+
+
+def __getattr__(name: str):
+    if name == "RepoMaps":
+        from .map_models import RepoMaps  # noqa: PLC0415
+        return RepoMaps
+    raise AttributeError("module %r has no attribute %r" % (__name__, name))

vigil_mapper/_ast_helpers_minimal.py

@@ -0,0 +1,229 @@
+"""Minimal inlined AST helpers — no cross-cluster imports.
+
+Inlined from the originating modules in the parent app (pure stdlib, no external deps):
+  - gate_models: GateFinding, EvidenceReference, enums
+  - _ast_helpers: parse_python_source_or_emit_finding
+"""
+from __future__ import annotations
+
+import ast
+import hashlib
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Callable, Optional
+
+
+# ---------------------------------------------------------------------------
+# Gate model vocabulary (inlined — pure stdlib enums and dataclasses)
+# ---------------------------------------------------------------------------
+
+class GateVerdict(str, Enum):
+    PASS = "pass"
+    REVISE = "revise"
+    BLOCK = "block"
+
+
+class RepairKind(str, Enum):
+    REFACTOR               = "refactor"
+    CONSOLIDATE            = "consolidate"
+    ADD_PROOF              = "add_proof"
+    ADD_TEST               = "add_test"
+    FIX_CONTRACT           = "fix_contract"
+    REMOVE_FALLBACK        = "remove_fallback"
+    SPLIT_MODULE           = "split_module"
+    EXTRACT_SHARED         = "extract_shared"
+    VALIDATE_BOUNDARY      = "validate_boundary"
+    REMOVE_DUPLICATE       = "remove_duplicate"
+    EDIT_CANONICAL         = "edit_canonical_module"
+    ADD_BOUNDARY_CHECK     = "add_boundary_check"
+    REPLACE_WITH_FAIL_LOUD = "replace_fallback_with_fail_loud"
+    ADD_MISSING_PROOF      = "add_missing_proof"
+    ADD_REGRESSION_TEST    = "add_regression_test"
+    REMOVE_DEAD_SURFACE    = "remove_dead_surface"
+    NORMALIZE_SHAPE        = "normalize_shape"
+    FIX_ENCODING           = "fix_encoding_safety"
+    INVESTIGATE_GATE_FAILURE = "investigate_gate_failure"
+    FIX_SYNTAX             = "fix_syntax"
+
+
+class GateSeverity(str, Enum):
+    INFO = "info"
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+    CRITICAL = "critical"
+
+
+class GateImpact(str, Enum):
+    WARN = "warn"
+    REVISE = "revise"
+    BLOCK = "block"
+
+
+class GateCategory(str, Enum):
+    CONTRACT = "contract_integrity"
+    TRUTH_BOUNDARY = "truth_boundary"
+    DRIFT = "drift"
+    FALLBACK = "fallback_hack_workaround"
+    DUPLICATION = "duplication_shadow_logic"
+    CONFIG_SSOT = "config_ssot"
+    RUNTIME_BEHAVIOR = "runtime_behavior"
+    PERFORMANCE = "performance"
+    SIZE_COMPLEXITY = "size_complexity"
+    TESTING = "testing_anti_patterns"
+    REPORTING = "reporting_artifact_integrity"
+    PIPELINE_CHAIN = "pipeline_chain_integrity"
+    SEMANTIC_INTENT = "semantic_intent"
+    TEMPORAL_FRESHNESS = "temporal_freshness"
+    TOOL_HOOK_COVERAGE = "tool_hook_coverage"
+    META = "meta_integrity"
+    OBSERVABILITY = "observability"
+
+
+@dataclass(frozen=True)
+class EvidenceReference:
+    kind: str
+    path: str = ""
+    detail: str = ""
+    ok: bool = True
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"kind": self.kind, "path": self.path, "detail": self.detail, "ok": self.ok}
+
+
+@dataclass(frozen=True)
+class GateFinding:
+    check_id: str
+    category: GateCategory
+    title: str
+    severity: GateSeverity
+    impact: GateImpact
+    summary: str
+    recommendation: str
+    evidence: tuple[EvidenceReference, ...] = field(default_factory=tuple)
+    fingerprint: str = ""
+    repair_kind: str = ""
+    executor_action: str = ""
+    proof_required: str = ""
+    allowlist_allowed: bool = True
+    preferred_fix_shape: str = ""
+    confidence: float = 1.0
+    applicability: str = "applicable"
+    analysis_mode: str = "heuristic"
+    applicability_reason: str = ""
+
+    def __post_init__(self) -> None:
+        if not (0.0 <= float(self.confidence) <= 1.0):
+            raise ValueError(
+                f"GateFinding.confidence must be in [0.0, 1.0], got {self.confidence!r}"
+            )
+        if self.applicability not in ("applicable", "not_applicable", "unknown"):
+            raise ValueError(
+                f"GateFinding.applicability must be one of "
+                f"{{applicable, not_applicable, unknown}}, got {self.applicability!r}"
+            )
+        if self.applicability != "applicable" and not (self.applicability_reason or "").strip():
+            raise ValueError(
+                f"GateFinding.applicability_reason is required when applicability != 'applicable' "
+                f"(applicability={self.applicability!r}, check_id={self.check_id!r})"
+            )
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "check_id": self.check_id,
+            "category": self.category.value,
+            "title": self.title,
+            "severity": self.severity.value,
+            "impact": self.impact.value,
+            "summary": self.summary,
+            "recommendation": self.recommendation,
+            "evidence": [e.to_dict() for e in self.evidence],
+            "fingerprint": self.fingerprint,
+        }
+
+
+# ---------------------------------------------------------------------------
+# parse_python_source_or_emit_finding (inlined from _ast_helpers.py)
+# ---------------------------------------------------------------------------
+
+_PYTHON_EXTENSIONS: frozenset[str] = frozenset({".py", ".pyi"})
+
+
+def _looks_like_python_path(rel_path: str) -> bool:
+    if not rel_path:
+        return False
+    normalized = rel_path.replace("\\", "/").lower()
+    dot = normalized.rfind(".")
+    if dot < 0:
+        return False
+    return normalized[dot:] in _PYTHON_EXTENSIONS
+
+
+def build_syntax_parse_error_finding(
+    *,
+    rel_path: str,
+    exc: SyntaxError,
+    emitting_gate: str = "",
+) -> GateFinding:
+    line_info = f"line {exc.lineno}" if exc.lineno else "unknown line"
+    msg = str(exc.msg) if exc.msg else "unknown parse error"
+    evidence = (
+        EvidenceReference(
+            kind="syntax_error",
+            path=rel_path,
+            detail=f"{line_info}: {msg}"[:512],
+        ),
+    )
+    fp_source = f"meta.syntax_parse_error|{rel_path}|{exc.lineno}"
+    fingerprint = hashlib.sha256(fp_source.encode("utf-8")).hexdigest()[:16]
+    emitter_tag = f" [emitted by {emitting_gate}]" if emitting_gate else ""
+    return GateFinding(
+        check_id="meta.syntax_parse_error",
+        category=GateCategory.META,
+        title=f"Python syntax error in {rel_path} ({line_info})",
+        severity=GateSeverity.HIGH,
+        impact=GateImpact.REVISE,
+        summary=(
+            f"{rel_path}:{exc.lineno}: {msg}. Autoforensics gate could not "
+            f"parse this file and skipped its checks for this path.{emitter_tag}"
+        ),
+        recommendation=(
+            "Fix the Python syntax error so gates can parse and audit this "
+            "file. A silent skip hides real bugs from the audit."
+        ),
+        evidence=evidence,
+        fingerprint=fingerprint,
+        repair_kind=RepairKind.FIX_SYNTAX.value,
+        executor_action="fix Python syntax error",
+        proof_required="ast.parse succeeds on the file",
+        allowlist_allowed=False,
+        preferred_fix_shape="restore valid Python grammar; do not silence via except",
+    )
+
+
+def parse_python_source_or_emit_finding(
+    source: str,
+    *,
+    rel_path: str,
+    emit_finding: Optional[Callable[[GateFinding], None]] = None,
+    emitting_gate: str = "",
+    filename: str | None = None,
+) -> ast.Module | None:
+    """Parse Python source and return the AST module, or emit a meta finding."""
+    if not source:
+        return None
+    try:
+        return ast.parse(source, filename=filename or rel_path or "<unknown>")
+    except SyntaxError as exc:
+        if emit_finding is not None and _looks_like_python_path(rel_path):
+            try:
+                emit_finding(
+                    build_syntax_parse_error_finding(
+                        rel_path=rel_path,
+                        exc=exc,
+                        emitting_gate=emitting_gate,
+                    )
+                )
+            except Exception:
+                pass
+        return None

vigil_mapper/_extract_imports_impl.py

@@ -0,0 +1,123 @@
+"""Inlined import extractor — pure stdlib, no cross-cluster imports.
+
+Extracted from the prompt_engineer_graph module of the parent app.
+Provides: _extract_imports, ModuleNode, STANDARD_SKIP_DIRS.
+"""
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass, field
+from pathlib import Path
+
+# Standard skip dirs (from project_exclusions — inlined, pure stdlib)
+STANDARD_SKIP_DIRS: frozenset[str] = frozenset({
+    "__pycache__", ".git", ".hg", ".svn",
+    "node_modules", ".tox", ".mypy_cache", ".pytest_cache", ".ruff_cache",
+    ".venv", "venv", "env", ".env", ".eggs",
+    "dist", "build",
+    ".cortex", ".a1", ".prompt-engineer", ".claude", ".vendor",
+})
+
+
+@dataclass
+class ModuleNode:
+    """A Python module in the project."""
+    path: str  # relative to project root
+    package: str  # dotted module name
+    imports: list[str] = field(default_factory=list)
+    lazy_imports: list[str] = field(default_factory=list)
+    dynamic_imports: list[str] = field(default_factory=list)
+    re_exports: list[str] = field(default_factory=list)
+    all_names: list[str] = field(default_factory=list)
+    is_init: bool = False
+    is_entry_point: bool = False
+    is_test: bool = False
+    line_count: int = 0
+    mtime: float = 0.0
+
+
+def _build_parent_map(tree: ast.Module) -> dict[int, ast.AST]:
+    parent_map: dict[int, ast.AST] = {}
+    for parent in ast.walk(tree):
+        for child in ast.iter_child_nodes(parent):
+            parent_map[id(child)] = parent
+    return parent_map
+
+
+def _is_in_function(node: ast.AST, parent_map: dict[int, ast.AST]) -> bool:
+    current = parent_map.get(id(node))
+    while current is not None:
+        if isinstance(current, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            return True
+        current = parent_map.get(id(current))
+    return False
+
+
+def _extract_imports(source: str, file_path: str) -> ModuleNode:
+    """Parse a Python file and extract all import information."""
+    node = ModuleNode(path=file_path, package="")
+    lines = source.splitlines()
+    node.line_count = len(lines)
+
+    basename = Path(file_path).name
+    node.is_init = basename == "__init__.py"
+    node.is_test = basename.startswith("test_") or basename == "conftest.py"
+    node.is_entry_point = False
+
+    try:
+        tree = ast.parse(source, filename=file_path)
+    except SyntaxError:
+        return node
+
+    parent_map = _build_parent_map(tree)
+    re_exports_seen: set[str] = set()
+
+    for ast_node in ast.walk(tree):
+        if isinstance(ast_node, ast.Import):
+            for alias in ast_node.names:
+                target = node.lazy_imports if _is_in_function(ast_node, parent_map) else node.imports
+                target.append(alias.name)
+
+        elif isinstance(ast_node, ast.ImportFrom):
+            module = ast_node.module or ""
+            if ast_node.level > 0:
+                prefix = "." * ast_node.level
+                full = f"{prefix}{module}" if module else prefix
+            else:
+                full = module
+            target = node.lazy_imports if _is_in_function(ast_node, parent_map) else node.imports
+            target.append(full)
+
+            if node.is_init and not _is_in_function(ast_node, parent_map):
+                for alias in ast_node.names:
+                    key = f"{full}.{alias.name}"
+                    if key not in re_exports_seen:
+                        re_exports_seen.add(key)
+                        node.re_exports.append(key)
+
+        elif isinstance(ast_node, ast.Call):
+            func = ast_node.func
+            if isinstance(func, ast.Attribute) and func.attr == "import_module":
+                if ast_node.args and isinstance(ast_node.args[0], ast.Constant):
+                    node.dynamic_imports.append(str(ast_node.args[0].value))
+            elif isinstance(func, ast.Name) and func.id == "__import__":
+                if ast_node.args and isinstance(ast_node.args[0], ast.Constant):
+                    node.dynamic_imports.append(str(ast_node.args[0].value))
+
+        elif isinstance(ast_node, ast.Assign):
+            for target in ast_node.targets:
+                if isinstance(target, ast.Name) and target.id == "__all__":
+                    if isinstance(ast_node.value, (ast.List, ast.Tuple)):
+                        for elt in ast_node.value.elts:
+                            if isinstance(elt, ast.Constant) and isinstance(elt.value, str):
+                                node.all_names.append(elt.value)
+
+        elif isinstance(ast_node, ast.If):
+            test = ast_node.test
+            if (isinstance(test, ast.Compare)
+                    and isinstance(test.left, ast.Name) and test.left.id == "__name__"
+                    and any(isinstance(c, ast.Constant) and c.value == "__main__"
+                            for c in test.comparators)):
+                node.is_entry_point = True
+
+    return node