core-runtime 0.1.1__py3-none-any.whl

cli/commands/interactive_test.py

@@ -0,0 +1,85 @@
+# src/cli/commands/interactive_test.py
+"""
+Interactive test generation command.
+... (docstring remains the same)
+"""
+
+from __future__ import annotations
+
+import typer
+
+from cli.logic.interactive_test_logic import run_interactive_test_generation
+from cli.utils import core_command
+from shared.cli.command_meta import CommandBehavior, CommandLayer, command_meta
+from shared.context import CoreContext
+from shared.logger import getLogger
+
+
+logger = getLogger(__name__)
+app = typer.Typer(
+    help="Interactive test generation with step-by-step approval", no_args_is_help=True
+)
+
+
+@app.command("generate")
+@command_meta(
+    canonical_name="interactive-test.generate",
+    behavior=CommandBehavior.MUTATE,
+    layer=CommandLayer.WILL,
+    summary="Generate tests interactively with step-by-step prompts.",
+    dangerous=True,
+)
+@core_command(dangerous=True, requires_context=True)
+# ID: fbc18275-df5e-426a-b39e-78eea4048069
+async def generate_interactive(
+    ctx: typer.Context,
+    target: str = typer.Argument(
+        ...,
+        help="Module path to generate tests for (e.g., src/shared/models/knowledge.py)",
+    ),
+    write: bool = typer.Option(
+        False, "--write", help="Actually execute the final creation of the test file."
+    ),
+):
+    """
+    Generate tests interactively with step-by-step prompts.
+    ... (docstring remains the same)
+    """
+    core_context: CoreContext = ctx.obj
+    logger.info("=" * 80)
+    logger.info("🎯 Interactive Test Generation: %s", target)
+    logger.info("=" * 80)
+    try:
+        success = await run_interactive_test_generation(
+            target_file=target, core_context=core_context
+        )
+        if not success:
+            logger.warning("Interactive test generation cancelled by user")
+            raise typer.Exit(code=1)
+        logger.info("✅ Interactive test generation completed successfully")
+    except Exception as e:
+        logger.error("❌ Interactive test generation failed: %s", e, exc_info=True)
+        raise typer.Exit(code=1)
+
+
+@app.command("info")
+@command_meta(
+    canonical_name="interactive-test.info",
+    behavior=CommandBehavior.READ,
+    layer=CommandLayer.BODY,
+    summary="Display information about the interactive test generation workflow.",
+    dangerous=False,
+)
+# ID: f9dec947-696f-4f69-8892-567aa2fe4f4d
+def info():
+    """Show information about interactive test generation."""
+    from rich.console import Console
+    from rich.panel import Panel
+
+    console = Console()
+    console.print(
+        Panel.fit(
+            "[bold cyan]Interactive Test Generation[/bold cyan]\n\n[bold]Purpose:[/bold]\nGenerate tests with full visibility and control at each step.\n\n[bold]Features:[/bold]\n  • Step-by-step prompts and approval\n  • Code preview with syntax highlighting\n  • Edit at any step with $EDITOR\n  • Skip ahead or cancel anytime\n  • All artifacts saved to work/interactive/\n  • Complete decision log maintained\n\n[bold]Steps:[/bold]\n  1. [cyan]Generate[/cyan] - LLM creates test code\n  2. [cyan]Auto-heal[/cyan] - Fix imports, headers, format\n  3. [cyan]Audit[/cyan] - Constitutional governance check\n  4. [cyan]Canary[/cyan] - Optional sandbox trial\n  5. [cyan]Execute[/cyan] - Create the test file\n\n[bold]Usage:[/bold]\n  core-admin interactive-test generate <module-path>",
+            border_style="cyan",
+        )
+    )

cli/commands/mind.py

@@ -0,0 +1,49 @@
+# src/cli/commands/mind.py
+
+"""
+Registers the 'mind' command group for managing the Working Mind's SSOT.
+Refactored to use the Constitutional CLI Framework (@core_command).
+"""
+
+from __future__ import annotations
+
+import typer
+
+from cli.utils import core_command
+
+
+mind_app = typer.Typer(
+    help="Commands to manage the Working Mind (DB-as-SSOT).", no_args_is_help=True
+)
+
+
+@mind_app.command(
+    "validate-meta",
+    help="Validate all .intent documents against GLOBAL-DOCUMENT-META-SCHEMA.",
+)
+@core_command(dangerous=False, requires_context=False)
+# ID: eeca852a-b1d6-44c9-bb4f-5cadcd1307a9
+def validate_meta_command(ctx: typer.Context) -> None:
+    """Validate .intent documents against META-SCHEMA."""
+    from mind.governance.meta_validator import MetaValidator
+    from shared.logger import getLogger
+
+    logger = getLogger(__name__)
+    logger.info("Validating .intent documents against META-SCHEMA...")
+    validator = MetaValidator()
+    report = validator.validate_all_documents()
+    logger.info("\n📊 Validation Report:")
+    logger.info("  Documents checked: %s", report.documents_checked)
+    logger.info("  Valid: %s", report.documents_valid)
+    logger.info("  Invalid: %s", report.documents_invalid)
+    if report.warnings:
+        logger.warning("\n⚠️  Warnings (%s):", len(report.warnings))
+        for warning in report.warnings:
+            logger.warning("  %s: %s", warning.document, warning.message)
+    if report.errors:
+        logger.error("\n❌ Errors (%s):", len(report.errors))
+        for error in report.errors:
+            field_str = f" [{error.field}]" if error.field else ""
+            logger.error("  %s%s: %s", error.document, field_str, error.message)
+        raise typer.Exit(1)
+    logger.info("\n✅ All .intent documents valid")

cli/commands/refactor.py

@@ -0,0 +1,234 @@
+# src/cli/commands/refactor.py
+
+"""Refactoring analysis commands.
+
+Thin clients over /v1/refactor/{score,candidates,stats,threshold}
+(ADR-057 D2). Display logic stays in `refactor_support.display`; data
+fetching crosses the HTTP boundary via CoreApiClient.
+"""
+
+from __future__ import annotations
+
+import logging
+
+import typer
+from rich.table import Table
+
+from api.cli import CoreApiClient
+from cli.commands.refactor_support.display import RefactorDisplay
+from cli.commands.refactor_support.display import console as refactor_console
+from cli.commands.refactor_support.recommendations import RecommendationEngine
+from cli.utils import core_command
+
+
+logger = logging.getLogger(__name__)
+
+
+_DEFAULT_CANDIDATE_LIMIT = 50
+
+
+refactor_app = typer.Typer(
+    help="Refactoring analysis and suggestions", no_args_is_help=True
+)
+
+
+@refactor_app.command("analyze")
+@core_command(dangerous=False, requires_context=False)
+# ID: 2a5b3ac3-36f8-4345-ad5f-394634d924c2
+async def analyze_file(
+    ctx: typer.Context,
+    file_path: str = typer.Argument(..., help="File to analyze"),
+) -> None:
+    """Analyze a single file for refactoring opportunities."""
+    _ = ctx
+    client = CoreApiClient()
+    threshold_payload = await client.refactor_threshold()
+    target_value = float(threshold_payload.get("threshold", 60.0))
+
+    display = RefactorDisplay()
+    recommender = RecommendationEngine()
+
+    try:
+        score_payload = await client.refactor_score(file=file_path)
+    except Exception as exc:
+        display.console.print(f"[red]Error: {exc}[/red]")
+        raise typer.Exit(1) from exc
+
+    if not score_payload.get("found"):
+        display.console.print(f"[red]Error: File not found: {file_path}[/red]")
+        raise typer.Exit(1)
+
+    details = score_payload.get("details")
+    if not details:
+        display.show_clean_file()
+        return
+
+    display.show_file_analysis(file_path, details, target_value)
+    recommendations = recommender.generate(details)
+    if recommendations:
+        display.show_recommendations(recommendations)
+
+
+@refactor_app.command("suggest")
+@core_command(dangerous=False, requires_context=False)
+# ID: 3b5d6926-eb94-4ad8-994a-f5a0574f7da1
+async def suggest_candidates(
+    ctx: typer.Context,
+    min_score: float = typer.Option(
+        None, "--min-score", help="Filter by score (defaults to constitutional limit)"
+    ),
+    limit: int = typer.Option(
+        _DEFAULT_CANDIDATE_LIMIT, "--limit", help="Number of files to show"
+    ),
+) -> None:
+    """Rank and suggest files that need refactoring based on current score."""
+    _ = ctx
+    client = CoreApiClient()
+    threshold_payload = await client.refactor_threshold()
+    target_value = float(threshold_payload.get("threshold", 60.0))
+    display = RefactorDisplay()
+
+    display.console.print(
+        f"[bold cyan]🔍 Scanning Codebase (Target Score: <{target_value})...[/bold cyan]\n"
+    )
+
+    candidates_payload = await client.refactor_candidates(
+        min_score=min_score, limit=limit
+    )
+    candidates = candidates_payload.get("candidates", [])
+
+    if not candidates:
+        display.show_no_candidates()
+        return
+
+    shaped = [
+        {
+            "file": c.get("file", ""),
+            "score": float(c.get("score", 0.0)),
+            "resp": int(c.get("responsibility_count", 0)),
+            "loc": int(c.get("lines_of_code", 0)),
+        }
+        for c in candidates
+    ]
+    display.show_candidates_table(shaped, target_value, limit)
+
+
+@refactor_app.command("stats")
+@core_command(dangerous=False, requires_context=False)
+# ID: dac13339-709c-4be9-9f64-9bd5bfaf1db9
+async def show_stats(ctx: typer.Context) -> None:
+    """Show aggregate codebase modularity health using risk tiers."""
+    _ = ctx
+    client = CoreApiClient()
+    threshold_payload = await client.refactor_threshold()
+    target_value = float(threshold_payload.get("threshold", 60.0))
+    warning_level = target_value * 0.8
+
+    stats = await client.refactor_stats()
+    display = RefactorDisplay()
+
+    if not stats.get("count"):
+        display.console.print("[yellow]No Python files found for analysis.[/yellow]")
+        return
+
+    histogram = stats.get("histogram") or {}
+    # Map five-bucket histogram onto the high_risk / warning / healthy tiers
+    # that show_stats was built for.
+    high_risk = sum(
+        v for k, v in histogram.items() if _bucket_lower_bound(k) >= target_value
+    )
+    warning = sum(
+        v
+        for k, v in histogram.items()
+        if warning_level <= _bucket_lower_bound(k) < target_value
+    )
+    healthy = stats["count"] - high_risk - warning
+
+    display.show_stats(
+        total_files=stats["count"],
+        avg_score=float(stats.get("mean", 0.0)),
+        target_value=target_value,
+        high_risk=high_risk,
+        warning=warning,
+        healthy=healthy,
+    )
+
+
+@refactor_app.command("score")
+@core_command(dangerous=False, requires_context=False)
+# ID: 8b86cd83-5181-479d-aa80-6e98738841b6
+async def check_file_score(
+    ctx: typer.Context,
+    file_path: str = typer.Argument(..., help="File path to analyze"),
+) -> None:
+    """Check the modularity score for a single file with detailed breakdown."""
+    _ = ctx
+    client = CoreApiClient()
+    threshold_payload = await client.refactor_threshold()
+    target_value = float(threshold_payload.get("threshold", 60.0))
+
+    try:
+        payload = await client.refactor_score(file=file_path)
+    except Exception as exc:
+        RefactorDisplay.console.print(f"[red]Error: {exc}[/red]")
+        raise typer.Exit(1) from exc
+
+    if not payload.get("found"):
+        RefactorDisplay.console.print(f"[red]File not found: {file_path}[/red]")
+        raise typer.Exit(1)
+
+    details = payload.get("details")
+    if not details:
+        RefactorDisplay.console.print(
+            f"[green]✅ {file_path} is below threshold ({target_value})[/green]"
+        )
+        return
+
+    score = float(details["total_score"])
+    table = Table(title=f"Modularity Score: {file_path}")
+    table.add_column("Metric", style="cyan")
+    table.add_column("Value", justify="right")
+    table.add_column("Score", justify="right")
+
+    breakdown = details.get("breakdown", {})
+    table.add_row(
+        "Responsibilities",
+        str(details.get("responsibility_count", 0)),
+        f"{breakdown.get('responsibilities', 0):.1f}",
+    )
+    table.add_row(
+        "Cohesion",
+        f"{details.get('cohesion', 0):.2f}",
+        f"{breakdown.get('cohesion', 0):.1f}",
+    )
+    table.add_row(
+        "Coupling (Concerns)",
+        str(details.get("concern_count", 0)),
+        f"{breakdown.get('coupling', 0):.1f}",
+    )
+    table.add_row(
+        "Size (LOC)",
+        str(details.get("lines_of_code", 0)),
+        f"{breakdown.get('size', 0):.1f}",
+    )
+    table.add_row("", "", "")
+    table.add_row("TOTAL", "", f"[bold]{score:.1f}/100[/bold]")
+    table.add_row("Target", "", f"<{target_value}")
+    refactor_console.print(table)
+
+    if score > target_value:
+        RefactorDisplay.console.print(
+            f"\n[red]❌ Exceeds threshold by {score - target_value:.1f} points[/red]"
+        )
+    else:
+        refactor_console.print("\n[yellow]⚠️  Within warning range[/yellow]")
+
+
+def _bucket_lower_bound(bucket: str) -> float:
+    """Return the lower bound implied by a histogram bucket key."""
+    if bucket == "80+":
+        return 80.0
+    try:
+        return float(bucket.split("-", 1)[0])
+    except (ValueError, IndexError):
+        return 0.0

cli/commands/refactor_support/__init__.py

@@ -0,0 +1,7 @@
+# src/cli/commands/refactor_support/__init__.py
+
+"""
+Refactoring analysis support modules.
+"""
+
+from __future__ import annotations

cli/commands/refactor_support/analyzer.py

@@ -0,0 +1,107 @@
+# src/cli/commands/refactor_support/analyzer.py
+
+"""Analysis helper for refactoring candidates.
+
+Thin client over /v1/refactor/{score,candidates,stats} (ADR-057 D2). The
+API owns the ModularityChecker instance; this helper just adapts API
+payloads into the legacy dict shape used by refactor.py command bodies.
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+from api.cli import CoreApiClient
+
+
+logger = logging.getLogger(__name__)
+
+
+# ID: 64be4c1c-7799-46cf-a22d-100234b2d301
+class RefactorAnalyzer:
+    """Analyzes files for refactoring opportunities via the API."""
+
+    def __init__(self, repo_root: Path | None = None) -> None:
+        self.repo_root = repo_root
+
+    # ID: 7036cd6b-f1da-4546-bb02-f86f014b82cd
+    async def analyze_file(self, file_path: Path) -> dict | None:
+        """Analyze a single file and return detailed metrics.
+
+        Returns None if the file is exceptionally clean.
+        """
+        rel = self._relative(file_path)
+        client = CoreApiClient()
+        try:
+            payload = await client.refactor_score(file=rel)
+        except Exception as exc:
+            logger.debug("refactor analyzer: score fetch failed for %s: %s", rel, exc)
+            return None
+        if not payload.get("found"):
+            return None
+        return payload.get("details") or None
+
+    # ID: 0cd1f389-137b-4bbd-8fe8-bf3c8baee474
+    async def scan_codebase(
+        self, files: list[Path] | None, min_score: float
+    ) -> list[dict]:
+        """Return refactor candidates above `min_score`, highest score first.
+
+        `files` is retained for call-site compatibility but ignored — the
+        API scans the canonical src/ tree server-side.
+        """
+        _ = files
+        client = CoreApiClient()
+        payload = await client.refactor_candidates(min_score=min_score, limit=500)
+        candidates = []
+        for c in payload.get("candidates", []):
+            file_path = Path(c.get("file", ""))
+            if self.repo_root is not None:
+                file_path = (self.repo_root / file_path).resolve()
+            candidates.append(
+                {
+                    "file": file_path,
+                    "score": float(c.get("score", 0.0)),
+                    "resp": int(c.get("responsibility_count", 0)),
+                    "loc": int(c.get("lines_of_code", 0)),
+                }
+            )
+        return candidates
+
+    # ID: 412727a0-6221-4cd8-8b54-591b1f199374
+    async def collect_scores(self, files: list[Path] | None) -> list[float]:
+        """Collect all scores for statistical analysis.
+
+        `files` is retained for call-site compatibility but ignored — the
+        API delivers the codebase-wide score histogram server-side.
+        """
+        _ = files
+        client = CoreApiClient()
+        payload = await client.refactor_stats()
+        # The stats endpoint returns histogram buckets rather than raw scores;
+        # we expand the histogram to a list whose length matches `count`. This
+        # preserves caller expectations (len, mean, max), at the cost of
+        # losing per-score fidelity. Adequate for the stats command's display.
+        histogram = payload.get("histogram") or {}
+        scores: list[float] = []
+        bucket_midpoints = {
+            "0-20": 10.0,
+            "20-40": 30.0,
+            "40-60": 50.0,
+            "60-80": 70.0,
+            "80+": 90.0,
+        }
+        for bucket, count in histogram.items():
+            mid = bucket_midpoints.get(bucket, 0.0)
+            scores.extend([mid] * int(count))
+        return scores
+
+    def _relative(self, file_path: Path) -> str:
+        """Return a repo-relative POSIX path for the API."""
+        if self.repo_root is not None:
+            try:
+                return str(file_path.relative_to(self.repo_root)).replace("\\", "/")
+            except ValueError:
+                pass
+        return str(file_path).replace("\\", "/")

cli/commands/refactor_support/config.py

@@ -0,0 +1,67 @@
+# src/cli/commands/refactor_support/config.py
+
+"""Configuration and file enumeration for refactoring analysis.
+
+`get_modularity_threshold` thinly wraps GET /v1/refactor/threshold so the
+CLI doesn't reach into `mind.governance.enforcement_loader` directly.
+`get_source_files` stays as a stdlib filesystem walk — pure local
+enumeration, no CORE-internal imports.
+"""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Iterable
+from pathlib import Path
+
+from api.cli import CoreApiClient
+
+
+logger = logging.getLogger(__name__)
+
+
+# ID: 15dff2fb-d1d0-4d85-9fb8-7667e5b93b40
+async def get_modularity_threshold(repo_root: Path | None = None) -> float:
+    """Retrieve the authoritative `max_score` from the constitution via API.
+
+    `repo_root` retained for call-site compatibility; the API resolves
+    the repo root server-side now.
+    """
+    _ = repo_root
+    try:
+        client = CoreApiClient()
+        payload = await client.refactor_threshold()
+        return float(payload.get("threshold", 60.0))
+    except Exception as exc:
+        logger.debug(
+            "refactor.config: could not load modularity threshold via API: %s", exc
+        )
+        return 60.0
+
+
+# ID: f54112b9-6914-4af4-9f38-087b8837db95
+def get_source_files(repo_root: Path) -> Iterable[Path]:
+    """Standardized file enumerator. Filters junk/temp folders.
+
+    Pure local filesystem walk — no CORE-internal imports.
+    """
+    skip_dirs = {
+        ".venv",
+        "venv",
+        ".git",
+        "work",
+        "var",
+        "__pycache__",
+        ".pytest_cache",
+        "tests",
+        "migrations",
+        "reports",
+    }
+    src_root = repo_root / "src"
+    if not src_root.exists():
+        return []
+
+    for file in src_root.rglob("*.py"):
+        if any(part in file.parts for part in skip_dirs):
+            continue
+        yield file