mapify-cli 3.21.0__tar.gz → 3.22.0__tar.gz

{mapify_cli-3.21.0 → mapify_cli-3.22.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapify-cli
-Version: 3.21.0
+Version: 3.22.0
 Summary: MAP Framework installer - Modular Agentic Planner for Claude Code
 Project-URL: Homepage, https://github.com/azalio/map-framework
 Project-URL: Repository, https://github.com/azalio/map-framework.git
@@ -291,6 +291,7 @@ mapify init . --no-autonomy     # remove the autonomy posture
 |-------|-------------|
 | [Installation](docs/INSTALL.md) | All install methods, PATH setup, troubleshooting |
 | [Usage Guide](docs/USAGE.md) | Workflows, examples, cost optimization, playbook |
+| [Prompt Library](docs/PROMPT_LIBRARY.md) | Copyable prompt recipes by SDLC phase and role |
 | [Architecture](docs/ARCHITECTURE.md) | Agents, MCP integration, customization |
 | [Platform Spec](docs/MAP_PLATFORM_SPEC.md) | Platform refactor roadmap, codebase analysis |
 

{mapify_cli-3.21.0 → mapify_cli-3.22.0}/README.md

@@ -246,6 +246,7 @@ mapify init . --no-autonomy     # remove the autonomy posture
 |-------|-------------|
 | [Installation](docs/INSTALL.md) | All install methods, PATH setup, troubleshooting |
 | [Usage Guide](docs/USAGE.md) | Workflows, examples, cost optimization, playbook |
+| [Prompt Library](docs/PROMPT_LIBRARY.md) | Copyable prompt recipes by SDLC phase and role |
 | [Architecture](docs/ARCHITECTURE.md) | Agents, MCP integration, customization |
 | [Platform Spec](docs/MAP_PLATFORM_SPEC.md) | Platform refactor roadmap, codebase analysis |
 

{mapify_cli-3.21.0 → mapify_cli-3.22.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mapify-cli"
-version = "3.21.0"
+version = "3.22.0"
 description = "MAP Framework installer - Modular Agentic Planner for Claude Code"
 authors = [{ name = "MAP Framework Contributors" }]
 readme = "README.md"

{mapify_cli-3.21.0 → mapify_cli-3.22.0}/src/mapify_cli/__init__.py

@@ -23,7 +23,7 @@ Or install globally:
     mapify check
 """
 
-__version__ = "3.21.0"
+__version__ = "3.22.0"
 
 import os
 import subprocess
@@ -152,6 +152,27 @@ research_eval_app = typer.Typer(
 
 app.add_typer(research_eval_app, name="research-eval")
 
+code_map_app = typer.Typer(
+    name="code-map",
+    help="Structural code-map provider for MAP research (Python AST fallback).",
+)
+
+app.add_typer(code_map_app, name="code-map")
+
+domain_skill_app = typer.Typer(
+    name="domain-skill",
+    help="Bootstrap a project-local domain/reference skill for Claude Code.",
+)
+
+app.add_typer(domain_skill_app, name="domain-skill")
+
+governance_app = typer.Typer(
+    name="governance",
+    help="Inventory and audit MAP behavior-shaping assets installed in a project.",
+)
+
+app.add_typer(governance_app, name="governance")
+
 
 def version_callback(value: bool):
     """Callback to show version and exit."""
@@ -1003,6 +1024,22 @@ def init(
             else:
                 tracker.error("git", "failed")
 
+    # Write install manifest (.map/mapify.lock.json) — scan-based, after all files
+    # have been installed by both providers.
+    tracker.add("manifest", "Write install manifest")
+    tracker.start("manifest")
+    try:
+        from mapify_cli.install_manifest import build_manifest, write_manifest
+
+        manifest = build_manifest(project_path, provider, __version__)
+        manifest_path = write_manifest(project_path, manifest)
+        tracker.complete(
+            "manifest",
+            f"{len(manifest.entries)} entries → {manifest_path.relative_to(project_path)}",
+        )
+    except Exception as _manifest_exc:
+        tracker.error("manifest", f"skipped: {_manifest_exc}")
+
     tracker.add("finalize", "Finalize")
     tracker.complete("finalize", "project ready")
 
@@ -1571,6 +1608,160 @@ def upgrade():
     )
 
 
+@app.command("check-installed")
+def check_installed(
+    project_path: Optional[Path] = typer.Argument(
+        None,
+        help="Project root directory (defaults to current directory).",
+    ),
+) -> None:
+    """Compare installed MAP files against .map/mapify.lock.json.
+
+    Reports missing files (in manifest but absent from disk), orphaned files
+    (MAP-managed on disk but not recorded in the manifest), and drifted files
+    (template hash differs from the manifest record).
+
+    Exit codes: 0 = all ok, 1 = issues found, 2 = no manifest.
+    """
+    from mapify_cli.install_manifest import check_installed as _check_installed
+    from mapify_cli.install_manifest import read_manifest
+
+    target = project_path or Path.cwd()
+
+    manifest = read_manifest(target)
+    if manifest is None:
+        console.print(
+            f"[yellow]No install manifest found at {target / '.map' / 'mapify.lock.json'}[/yellow]"
+        )
+        console.print(
+            "[dim]Run [cyan]mapify init .[/cyan] to generate the manifest.[/dim]"
+        )
+        raise typer.Exit(2)
+
+    console.print(
+        f"[bold]MAP install manifest[/bold] — provider: [cyan]{manifest.provider}[/cyan], "
+        f"version: [cyan]{manifest.mapify_version}[/cyan], "
+        f"installed: [dim]{manifest.installed_at}[/dim]"
+    )
+    console.print(f"[dim]{len(manifest.entries)} entries recorded[/dim]")
+    console.print()
+
+    result = _check_installed(target)
+
+    has_issues = False
+
+    if result.missing:
+        has_issues = True
+        console.print(f"[red]Missing ({len(result.missing)} files):[/red]")
+        for path in result.missing:
+            console.print(f"  [red]✗[/red] {path}")
+
+    if result.orphaned:
+        has_issues = True
+        console.print(f"[yellow]Orphaned ({len(result.orphaned)} files):[/yellow]")
+        for path in result.orphaned:
+            console.print(f"  [yellow]?[/yellow] {path}")
+
+    if result.drifted:
+        has_issues = True
+        console.print(f"[yellow]Drifted ({len(result.drifted)} files):[/yellow]")
+        for path in result.drifted:
+            console.print(f"  [yellow]~[/yellow] {path}")
+
+    if result.ok and not has_issues:
+        console.print(
+            f"[green]✅ All {len(result.ok)} managed files match the manifest.[/green]"
+        )
+    elif not has_issues:
+        console.print("[green]✅ No issues found.[/green]")
+    else:
+        console.print()
+        console.print(
+            "[dim]Run [cyan]mapify init . --force[/cyan] to refresh managed files.[/dim]"
+        )
+        raise typer.Exit(1)
+
+
+@app.command()
+def uninstall(
+    project_path: Optional[Path] = typer.Argument(
+        None,
+        help="Project root directory (defaults to current directory).",
+    ),
+    yes: bool = typer.Option(
+        False,
+        "--yes",
+        "-y",
+        help="Skip confirmation prompt.",
+    ),
+) -> None:
+    """Remove MAP-owned config entries from provider config files.
+
+    Reads .map/mapify.lock.json and removes only the config-merge entries
+    MAP injected (MCP server keys in .mcp.json, the MAP statusline in
+    settings.local.json).  User-modified or user-owned entries are
+    preserved.  Installed files (.claude/, .map/scripts/, etc.) are
+    NOT removed by this command.
+
+    Exit codes: 0 = ok / nothing to remove, 1 = error, 2 = no manifest.
+    """
+    from mapify_cli.install_manifest import read_manifest, reconcile_config
+
+    target = project_path or Path.cwd()
+
+    manifest = read_manifest(target)
+    if manifest is None:
+        console.print(
+            f"[yellow]No install manifest found at "
+            f"{target / '.map' / 'mapify.lock.json'}[/yellow]"
+        )
+        console.print("[dim]Run [cyan]mapify init .[/cyan] to generate the manifest.[/dim]")
+        raise typer.Exit(2)
+
+    if not manifest.config_entries:
+        console.print("[green]No MAP-owned config entries in the manifest.[/green]")
+        return
+
+    console.print(
+        f"[bold]MAP config entries to remove[/bold] "
+        f"(provider: [cyan]{manifest.provider}[/cyan]):"
+    )
+    for entry in manifest.config_entries:
+        console.print(f"  [dim]{entry.file}[/dim]  [cyan]{entry.key_path}[/cyan]")
+
+    console.print()
+    if not yes:
+        confirm = typer.confirm(
+            "Remove these MAP-owned config entries?",
+            default=False,
+        )
+        if not confirm:
+            console.print("[dim]Aborted.[/dim]")
+            return
+
+    result = reconcile_config(target)
+
+    if result.removed:
+        console.print(f"[green]Removed ({len(result.removed)}):[/green]")
+        for label in result.removed:
+            console.print(f"  [green]✓[/green] {label}")
+
+    if result.skipped:
+        console.print(
+            f"[yellow]Skipped ({len(result.skipped)}) — user-modified, preserved:[/yellow]"
+        )
+        for label in result.skipped:
+            console.print(f"  [yellow]~[/yellow] {label}")
+
+    if result.missing:
+        console.print(f"[dim]Already absent ({len(result.missing)}):[/dim]")
+        for label in result.missing:
+            console.print(f"  [dim]-[/dim] {label}")
+
+    if not result.removed and not result.skipped and not result.missing:
+        console.print("[dim]Nothing to do.[/dim]")
+
+
 # Research localization eval commands
 
 
@@ -1678,6 +1869,127 @@ def research_eval_score(
         raise typer.Exit(1)
 
 
+@research_eval_app.command("compare")
+def research_eval_compare(
+    baseline_file: Path = typer.Argument(
+        ...,
+        help="ResearchEvidence JSON/text from the baseline discovery arm (e.g. glob_grep)",
+    ),
+    treatment_file: Path = typer.Argument(
+        ...,
+        help="ResearchEvidence JSON/text from the treatment discovery arm (e.g. structural-map)",
+    ),
+    expected_file: Path = typer.Argument(
+        ...,
+        help="JSON list, or object with expected_locations, of target file ranges",
+    ),
+    baseline_name: str = typer.Option(
+        "baseline",
+        "--baseline-name",
+        help="Display name for the baseline arm",
+    ),
+    treatment_name: str = typer.Option(
+        "treatment",
+        "--treatment-name",
+        help="Display name for the treatment arm",
+    ),
+    repo_root: Optional[Path] = typer.Option(
+        None,
+        "--repo-root",
+        help="Fixture repository root for path existence (stale detection) and line validation",
+    ),
+    min_treatment_file_f1: float = typer.Option(
+        0.0,
+        "--min-file-f1",
+        min=0.0,
+        max=1.0,
+        help="Hard quality floor on treatment file-level F1 (token-only wins are not enough)",
+    ),
+    min_treatment_line_f1: float = typer.Option(
+        0.0,
+        "--min-line-f1",
+        min=0.0,
+        max=1.0,
+        help="Hard quality floor on treatment line-level F1",
+    ),
+    max_stale_regression: int = typer.Option(
+        0,
+        "--max-stale-regression",
+        min=0,
+        help="Max allowed increase in stale/missing-file locations for treatment vs baseline",
+    ),
+    overbroad_line_threshold: int = typer.Option(
+        50,
+        "--overbroad-line-threshold",
+        min=1,
+        help="Locations with span above this are counted as over-broad",
+    ),
+    no_warn_regression: bool = typer.Option(
+        False,
+        "--no-warn-regression",
+        help="Suppress quality-regression warnings (treatment vs baseline delta)",
+    ),
+    out: Optional[Path] = typer.Option(
+        None,
+        "--out",
+        help="Write JSON report to this file (default: stdout only)",
+    ),
+) -> None:
+    """Compare two ResearchEvidence discovery arms (baseline vs treatment).
+
+    Scores quality (precision/recall/F1) and exploration-cost metrics
+    (location_count, stale_count, overbroad_count) separately so token/LOC
+    reduction cannot mask lower evidence quality.
+
+    Exit codes:
+      0 - Treatment meets all hard quality floors and stale-regression limits
+      1 - Hard failure: quality floor not met or stale regression exceeded
+      2 - Input files are missing or malformed
+    """
+    import json
+
+    from mapify_cli.research_eval_compare import compare_research_files
+
+    for label, path in [
+        ("baseline", baseline_file),
+        ("treatment", treatment_file),
+        ("expected", expected_file),
+    ]:
+        if not path.is_file():
+            console.print(f"[bold red]Error:[/bold red] {label} file not found: {path}")
+            raise typer.Exit(2)
+
+    root = repo_root.resolve() if repo_root else None
+    try:
+        report = compare_research_files(
+            baseline_file,
+            treatment_file,
+            expected_file,
+            baseline_name=baseline_name,
+            treatment_name=treatment_name,
+            repo_root=root,
+            overbroad_line_threshold=overbroad_line_threshold,
+            min_treatment_file_f1=min_treatment_file_f1,
+            min_treatment_line_f1=min_treatment_line_f1,
+            max_stale_regression=max_stale_regression,
+            warn_on_quality_regression=not no_warn_regression,
+        )
+    except (OSError, ValueError) as exc:
+        console.print(f"[bold red]Error:[/bold red] {exc}")
+        raise typer.Exit(2)
+
+    payload = report.as_dict()
+    output_json = json.dumps(payload, indent=2, sort_keys=True)
+    print(output_json)
+
+    if out is not None:
+        out.parent.mkdir(parents=True, exist_ok=True)
+        out.write_text(output_json + "\n", encoding="utf-8")
+
+    if not report.passed:
+        raise typer.Exit(1)
+
+
 # Skill-eval commands
 
 
@@ -2116,3 +2428,193 @@ def main():
 
 if __name__ == "__main__":
     main()
+
+
+# ---------------------------------------------------------------------------
+# Code-map commands
+# ---------------------------------------------------------------------------
+
+
+@code_map_app.command("query")
+def code_map_query(
+    query: str = typer.Argument(..., help="Symbol name or keyword to search for."),
+    repo_root: Path = typer.Option(
+        Path("."),
+        "--repo-root",
+        "-r",
+        help="Root of the repository to index (default: current directory).",
+    ),
+    max_results: int = typer.Option(
+        5,
+        "--max-results",
+        "-n",
+        min=1,
+        max=20,
+        help="Maximum number of locations to return (default 5).",
+    ),
+    out: Optional[Path] = typer.Option(
+        None,
+        "--out",
+        help="Write ResearchEvidence JSON to this file (default: stdout only).",
+    ),
+) -> None:
+    """Query the structural code map for a symbol and emit ResearchEvidence JSON.
+
+    Scans all Python files under REPO_ROOT using AST parsing (no external
+    dependencies required) and returns matching symbol locations compatible
+    with the existing ResearchEvidence contract.
+
+    Exit codes:
+      0 - One or more matching locations found.
+      1 - No matches found, empty index, or error.
+    """
+    from mapify_cli.code_map import query_code_map
+
+    result = query_code_map(query, repo_root.resolve(), max_results=max_results)
+    evidence = result.as_research_evidence()
+
+    print(evidence)
+
+    if out is not None:
+        out.parent.mkdir(parents=True, exist_ok=True)
+        out.write_text(evidence + "\n", encoding="utf-8")
+
+    if result.status not in ("ok",):
+        raise typer.Exit(1)
+
+
+# ---------------------------------------------------------------------------
+# Domain-skill commands
+# ---------------------------------------------------------------------------
+
+
+@domain_skill_app.command("init")
+def domain_skill_init(
+    project_path: Optional[str] = typer.Argument(
+        None,
+        help="Project directory to bootstrap the domain skill in (default: current directory)",
+    ),
+    name: Optional[str] = typer.Option(
+        None,
+        "--name",
+        help="Skill name in kebab-case (default: <project-name>-domain)",
+    ),
+    overwrite: bool = typer.Option(
+        False,
+        "--overwrite",
+        help="Overwrite an existing domain skill file",
+    ),
+) -> None:
+    """Bootstrap a project-local domain/reference skill.
+
+    Scans README.md, pyproject.toml, package.json, go.mod, and Makefile to
+    extract factual content. Missing facts become explicit placeholders for you
+    to fill. No content is fabricated, and secrets are never read or emitted.
+
+    The generated .claude/skills/<name>/SKILL.md is yours — it is not a
+    MAP-managed shipped template and will not be overwritten by mapify init.
+
+    This differs from /map-learn: this skill provides day-one project context
+    before any workflow runs; /map-learn captures lessons after a run completes.
+
+    Examples:
+
+        mapify domain-skill init
+
+        mapify domain-skill init . --name myproject-domain
+
+        mapify domain-skill init /path/to/project --overwrite
+    """
+    from mapify_cli.delivery.domain_skill import create_domain_skill
+
+    target = Path(project_path) if project_path else Path.cwd()
+    if not target.exists():
+        console.print(f"[red]Error:[/red] Path does not exist: {target}")
+        raise typer.Exit(1)
+
+    skill_file, created = create_domain_skill(target, skill_name=name, overwrite=overwrite)
+
+    rel = skill_file.relative_to(target)
+    if created:
+        console.print(f"[green]Created[/green] {rel}")
+        console.print(
+            "[dim]Edit the file and replace placeholders with real project facts.[/dim]"
+        )
+        console.print(
+            "[dim]Do not commit secrets, tokens, passwords, or API keys into this file.[/dim]"
+        )
+    else:
+        console.print(
+            f"[yellow]Skipped:[/yellow] {rel} already exists"
+            " (use --overwrite to replace)"
+        )
+
+
+# ---------------------------------------------------------------------------
+# Governance commands
+# ---------------------------------------------------------------------------
+
+
+@governance_app.command("report")
+def governance_report(
+    project_path: Optional[str] = typer.Argument(
+        None,
+        help="Project directory to audit (default: current directory)",
+    ),
+    output_json: bool = typer.Option(
+        False,
+        "--json",
+        help="Output the report as JSON instead of Markdown",
+    ),
+    out: Optional[str] = typer.Option(
+        None,
+        "--out",
+        help="Write the report to a file instead of stdout",
+    ),
+) -> None:
+    """Generate a governance report for MAP behavior-shaping assets.
+
+    Inventories installed skills, hooks, references, and learned rules in the
+    .claude/ directory and classifies each asset under six governance categories:
+    Charter, Policy, Context, Harness, Oversight, Learning.
+
+    Distinguishes enforced controls (runtime hooks) from prompt-only guidance
+    (skills, references, learned rules) and lists governance gaps where
+    policy claims rely solely on prompt text without a backing harness control.
+
+    Examples:
+
+        mapify governance report
+
+        mapify governance report /path/to/project
+
+        mapify governance report --json --out .map/governance.json
+    """
+    from mapify_cli.delivery.governance_report import build_governance_report
+
+    target = Path(project_path) if project_path else Path.cwd()
+    if not target.exists():
+        console.print(f"[red]Error:[/red] Path does not exist: {target}")
+        raise typer.Exit(1)
+
+    report = build_governance_report(target)
+
+    if not report.assets:
+        console.print(
+            f"[yellow]No MAP assets found[/yellow] in {target} — "
+            "run 'mapify init' first to install the MAP framework."
+        )
+        raise typer.Exit(1)
+
+    content = report.as_json() if output_json else report.as_markdown()
+
+    if out is not None:
+        out_path = Path(out)
+        out_path.parent.mkdir(parents=True, exist_ok=True)
+        out_path.write_text(content, encoding="utf-8")
+        console.print(f"[green]Written[/green] {out_path}")
+    elif output_json:
+        # Bypass Rich to avoid ANSI escape codes in JSON output
+        typer.echo(content)
+    else:
+        console.print(content)