mahu 1.0.0__py3-none-any.whl

mahu/__init__.py

@@ -0,0 +1,9 @@
+"""Mahu agent skill router."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("mahu")
+except PackageNotFoundError:  # pragma: no cover - source tree without install metadata
+    __version__ = "0.0.0"
+

mahu/cli.py

@@ -0,0 +1,107 @@
+"""Mahu CLI."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import click
+
+from mahu import __version__
+from mahu.dependencies import check_all_dependencies, check_dependency
+from mahu.enable import SUPPORTED_AGENTS, enable_agent
+from mahu.manifest import validate_manifest
+from mahu.router import route_request
+
+
+@click.group()
+@click.version_option(__version__, prog_name="mahu")
+def main():
+    """Mahu — agent skill router for daily AI work."""
+
+
+@main.command()
+@click.argument("request", nargs=-1, required=True)
+@click.option("--json-output", is_flag=True, default=False, help="Output structured JSON.")
+def route(request: tuple[str, ...], json_output: bool):
+    """Route a request to Mahu subskills."""
+    text = " ".join(request)
+    try:
+        result = route_request(text)
+    except ValueError as exc:
+        click.secho(f"✗ {exc}", fg="red", err=True)
+        raise SystemExit(1) from exc
+    if json_output:
+        click.echo(json.dumps(result.to_dict(), indent=2, ensure_ascii=False))
+        return
+    click.secho(f"primary: {result.primary}", fg="green", bold=True)
+    click.echo(f"sequence: {' -> '.join(result.sequence)}")
+    click.echo(f"load: {', '.join(result.references)}")
+    click.echo(f"reason: {result.reason}")
+
+
+@main.command()
+@click.option("--root", type=click.Path(exists=True, file_okay=False, path_type=Path), default=".", help="Mahu repo root.")
+@click.option("--json-output", is_flag=True, default=False, help="Output structured JSON.")
+def validate(root: Path, json_output: bool):
+    """Validate Mahu skill repository structure."""
+    report = validate_manifest(root)
+    if json_output:
+        click.echo(json.dumps(report.to_dict(), indent=2, ensure_ascii=False))
+    elif report.valid:
+        click.secho("✓ Mahu skill manifest is valid", fg="green", bold=True)
+    else:
+        for error in report.errors:
+            click.secho(f"✗ {error}", fg="red", err=True)
+    if not report.valid:
+        raise SystemExit(1)
+
+
+@main.command()
+@click.option("--subskill", default=None, help="Check one subskill dependency.")
+@click.option("--json-output", is_flag=True, default=False, help="Output structured JSON.")
+def doctor(subskill: str | None, json_output: bool):
+    """Check CLI dependencies required by Mahu subskills."""
+    try:
+        statuses = (check_dependency(subskill),) if subskill else check_all_dependencies()
+    except ValueError as exc:
+        click.secho(f"✗ {exc}", fg="red", err=True)
+        raise SystemExit(1) from exc
+    payload = {"ok": all(status.found for status in statuses), "dependencies": [status.to_dict() for status in statuses]}
+    if json_output:
+        click.echo(json.dumps(payload, indent=2, ensure_ascii=False))
+        return
+    for status in statuses:
+        marker = "✓" if status.found else "✗"
+        detail = status.version or status.path or status.dependency.install
+        color = "green" if status.found else "yellow"
+        click.secho(f"{marker} {status.dependency.subskill}: {status.dependency.command} - {detail}", fg=color)
+    if not payload["ok"]:
+        raise SystemExit(1)
+
+
+@main.command()
+@click.argument("agent", type=click.Choice(SUPPORTED_AGENTS))
+@click.option("--target", type=click.Path(file_okay=False, path_type=Path), default=".", help="Target project directory.")
+@click.option("--root", type=click.Path(exists=True, file_okay=False, path_type=Path), default=".", help="Mahu repo root.")
+@click.option("--json-output", is_flag=True, default=False, help="Output structured JSON.")
+def enable(agent: str, target: Path, root: Path, json_output: bool):
+    """Enable Mahu into a local agent workspace."""
+    try:
+        report = validate_manifest(root)
+        if not report.valid:
+            raise ValueError("; ".join(report.errors))
+        result = enable_agent(root, target, agent)
+    except ValueError as exc:
+        click.secho(f"✗ {exc}", fg="red", err=True)
+        raise SystemExit(1) from exc
+    if json_output:
+        click.echo(json.dumps(result.to_dict(), indent=2, ensure_ascii=False))
+        return
+    click.secho(f"✓ Mahu enabled for {agent}", fg="green", bold=True)
+    for path in result.files:
+        click.echo(f"  {path}")
+
+
+if __name__ == "__main__":
+    main()  # pragma: no cover

mahu/dependencies.py

@@ -0,0 +1,108 @@
+"""Dependency checks for Mahu subskills."""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+from dataclasses import dataclass
+from typing import Callable
+
+from mahu.router import get_subskill, list_subskills
+
+
+@dataclass(frozen=True)
+class Dependency:
+    subskill: str
+    owner: str
+    command: str
+    package: str
+    install: str
+    purpose: str
+
+    def to_dict(self) -> dict:
+        return {
+            "subskill": self.subskill,
+            "owner": self.owner,
+            "command": self.command,
+            "package": self.package,
+            "install": self.install,
+            "purpose": self.purpose,
+        }
+
+
+@dataclass(frozen=True)
+class DependencyStatus:
+    dependency: Dependency
+    found: bool
+    path: str | None = None
+    version: str | None = None
+
+    def to_dict(self) -> dict:
+        data = self.dependency.to_dict()
+        data.update({"found": self.found, "path": self.path, "version": self.version})
+        return data
+
+
+DEPENDENCIES: tuple[Dependency, ...] = (
+    Dependency("context", "fcontext", "fcontext", "fcontext", "pip install fcontext", "topics, requirements, decisions, and durable context"),
+    Dependency("prototype", "fdesign", "fdesign", "fdesign", "pip install fdesign", "prototype and design-system workflow"),
+    Dependency("presentation", "fppt", "fppt", "fppt", "pip install fppt", "presentation and HTML deck workflow"),
+    Dependency("review", "floop-client", "floop", "floop", "pip install floop", "review project/version upload and comments"),
+    Dependency("test", "testboat", "testboat", "testboat", "pip install testboat", "tests, QA, regression, and acceptance evidence"),
+)
+
+_DEPENDENCY_BY_SUBSKILL = {dependency.subskill: dependency for dependency in DEPENDENCIES}
+
+
+def list_dependencies() -> tuple[Dependency, ...]:
+    """Return dependency contracts in subskill order."""
+    return DEPENDENCIES
+
+
+def get_dependency(subskill: str) -> Dependency:
+    """Return the dependency contract for a subskill."""
+    get_subskill(subskill)
+    return _DEPENDENCY_BY_SUBSKILL[subskill]
+
+
+def check_dependency(
+    subskill: str,
+    *,
+    which: Callable[[str], str | None] = shutil.which,
+    runner: Callable[..., subprocess.CompletedProcess] = subprocess.run,
+) -> DependencyStatus:
+    """Check whether the CLI required by a subskill is available."""
+    dependency = get_dependency(subskill)
+    path = which(dependency.command)
+    if not path:
+        return DependencyStatus(dependency, found=False)
+    version = _read_version(dependency.command, runner)
+    return DependencyStatus(dependency, found=True, path=path, version=version)
+
+
+def check_all_dependencies(
+    *,
+    which: Callable[[str], str | None] = shutil.which,
+    runner: Callable[..., subprocess.CompletedProcess] = subprocess.run,
+) -> tuple[DependencyStatus, ...]:
+    """Check all subskill dependencies."""
+    return tuple(
+        check_dependency(subskill.name, which=which, runner=runner)
+        for subskill in list_subskills()
+    )
+
+
+def _read_version(command: str, runner: Callable[..., subprocess.CompletedProcess]) -> str | None:
+    try:
+        result = runner(
+            [command, "--version"],
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    output = (result.stdout or result.stderr or "").strip()
+    return output.splitlines()[0] if output else None
+

mahu/enable.py

@@ -0,0 +1,110 @@
+"""Enable Mahu skill files into agent-specific local directories."""
+
+from __future__ import annotations
+
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+
+
+SUPPORTED_AGENTS = ("codex", "workbuddy", "copilot", "opencode")
+MARKER_START = "<!-- mahu:skill -->"
+MARKER_END = "<!-- /mahu:skill -->"
+
+
+@dataclass(frozen=True)
+class EnableResult:
+    agent: str
+    target: Path
+    files: tuple[Path, ...]
+
+    def to_dict(self) -> dict:
+        return {
+            "agent": self.agent,
+            "target": str(self.target),
+            "files": [str(path) for path in self.files],
+        }
+
+
+def enable_agent(repo_root: Path, target: Path, agent: str) -> EnableResult:
+    """Enable Mahu into a target project for an agent."""
+    normalized = agent.lower()
+    if normalized not in SUPPORTED_AGENTS:
+        raise ValueError(f"Unsupported agent: {agent}")
+    source = repo_root.resolve()
+    destination_root = _agent_skill_dir(target.resolve(), normalized)
+    created = _copy_skill_bundle(source, destination_root)
+    if normalized == "copilot":
+        created += (_write_copilot_instruction(target.resolve()),)
+    if normalized == "opencode":
+        created += (_write_agents_md(target.resolve()),)
+    return EnableResult(normalized, target.resolve(), tuple(created))
+
+
+def _agent_skill_dir(target: Path, agent: str) -> Path:
+    if agent == "codex":
+        return target / ".codex" / "skills" / "mahu"
+    if agent == "workbuddy":
+        return target / ".workbuddy" / "skills" / "mahu"
+    if agent == "copilot":
+        return target / ".github" / "skills" / "mahu"
+    if agent == "opencode":
+        return target / ".opencode" / "skills" / "mahu"
+    raise ValueError(f"Unsupported agent: {agent}")  # pragma: no cover - guarded by enable_agent
+
+
+def _copy_skill_bundle(source: Path, destination: Path) -> tuple[Path, ...]:
+    destination.mkdir(parents=True, exist_ok=True)
+    created: list[Path] = []
+    for filename in ("SKILL.md",):
+        target = destination / filename
+        shutil.copyfile(source / filename, target)
+        created.append(target)
+    for directory in ("skills", "adapters"):
+        source_dir = source / directory
+        target_dir = destination / directory
+        if target_dir.exists():
+            shutil.rmtree(target_dir)
+        shutil.copytree(source_dir, target_dir)
+        created.extend(path for path in sorted(target_dir.rglob("*")) if path.is_file())
+    return tuple(created)
+
+
+def _write_copilot_instruction(target: Path) -> Path:
+    path = target / ".github" / "instructions" / "mahu.instructions.md"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        "---\n"
+        "description: 'Use Mahu as the router for context, prototype, presentation, review, and test work.'\n"
+        "applyTo: '**'\n"
+        "---\n\n"
+        "When the user invokes `/mahu`, read `.github/skills/mahu/SKILL.md` and follow its routing SOP.\n",
+        encoding="utf-8",
+    )
+    return path
+
+
+def _write_agents_md(target: Path) -> Path:
+    path = target / "AGENTS.md"
+    section = (
+        f"{MARKER_START}\n"
+        "## Mahu\n\n"
+        "Use Mahu for `/mahu` requests. Read `.opencode/skills/mahu/SKILL.md`, "
+        "classify the request, and load only the needed `skills/*.md` reference.\n"
+        f"{MARKER_END}\n"
+    )
+    if path.exists():
+        content = path.read_text(encoding="utf-8")
+        if MARKER_START in content:
+            before = content[: content.index(MARKER_START)]
+            if MARKER_END in content:
+                after = content[content.index(MARKER_END) + len(MARKER_END) :]
+            else:
+                after = ""
+            content = before + section + after
+        else:
+            content = content.rstrip() + "\n\n" + section
+    else:
+        content = section
+    path.write_text(content, encoding="utf-8")
+    return path

mahu/manifest.py

@@ -0,0 +1,69 @@
+"""Repository manifest validation for Mahu."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from mahu.router import list_subskills
+
+
+REQUIRED_ADAPTERS = ("codex", "workbuddy", "copilot", "opencode")
+
+
+@dataclass(frozen=True)
+class ManifestReport:
+    root: Path
+    valid: bool
+    errors: tuple[str, ...]
+    files: tuple[str, ...]
+
+    def to_dict(self) -> dict:
+        return {
+            "root": str(self.root),
+            "valid": self.valid,
+            "errors": list(self.errors),
+            "files": list(self.files),
+        }
+
+
+def validate_manifest(root: Path) -> ManifestReport:
+    """Validate that a Mahu repo has the expected skill-router files."""
+    resolved = root.resolve()
+    required_files = _required_files()
+    errors: list[str] = []
+    for relative in required_files:
+        path = resolved / relative
+        if not path.is_file():
+            errors.append(f"Missing required file: {relative}")
+            continue
+        if not path.read_text(encoding="utf-8").strip():
+            errors.append(f"Required file is empty: {relative}")
+    skill_path = resolved / "SKILL.md"
+    if skill_path.is_file():
+        _validate_skill_frontmatter(skill_path, errors)
+    return ManifestReport(resolved, not errors, tuple(errors), tuple(required_files))
+
+
+def _required_files() -> list[str]:
+    files = ["SKILL.md", "README.md", "pyproject.toml"]
+    files.extend(subskill.reference for subskill in list_subskills())
+    files.extend(f"adapters/{adapter}.md" for adapter in REQUIRED_ADAPTERS)
+    return files
+
+
+def _validate_skill_frontmatter(path: Path, errors: list[str]) -> None:
+    text = path.read_text(encoding="utf-8")
+    if not text.startswith("---\n"):
+        errors.append("SKILL.md must start with YAML frontmatter.")
+        return
+    try:
+        _, frontmatter, _body = text.split("---", 2)
+    except ValueError:
+        errors.append("SKILL.md frontmatter is not closed.")
+        return
+    if "name: mahu" not in frontmatter:
+        errors.append("SKILL.md frontmatter must include name: mahu.")
+    if "description:" not in frontmatter:
+        errors.append("SKILL.md frontmatter must include description.")
+

mahu/router.py

@@ -0,0 +1,150 @@
+"""Deterministic routing rules for Mahu."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Subskill:
+    name: str
+    owner: str
+    reference: str
+    keywords: tuple[str, ...]
+    description: str
+
+
+@dataclass(frozen=True)
+class RouteResult:
+    request: str
+    primary: str
+    sequence: tuple[str, ...]
+    references: tuple[str, ...]
+    confidence: str
+    reason: str
+
+    def to_dict(self) -> dict:
+        return {
+            "request": self.request,
+            "primary": self.primary,
+            "sequence": list(self.sequence),
+            "references": list(self.references),
+            "confidence": self.confidence,
+            "reason": self.reason,
+        }
+
+
+SUBSKILLS: tuple[Subskill, ...] = (
+    Subskill(
+        name="context",
+        owner="fcontext",
+        reference="skills/context.md",
+        keywords=("context", "memory", "topic", "requirement", "decision", "knowledge", "remember", "save"),
+        description="durable context, topics, requirements, and decisions",
+    ),
+    Subskill(
+        name="prototype",
+        owner="fdesign",
+        reference="skills/prototype.md",
+        keywords=("prototype", "ui", "website", "app", "design", "component", "token", "journey", "sitemap"),
+        description="prototype, UI, journey, tokens, components, and design-system work",
+    ),
+    Subskill(
+        name="presentation",
+        owner="fppt",
+        reference="skills/presentation.md",
+        keywords=("ppt", "slide", "slides", "deck", "presentation", "talk", "keynote", "share"),
+        description="presentations, decks, slides, and talks",
+    ),
+    Subskill(
+        name="review",
+        owner="floop-client",
+        reference="skills/review.md",
+        keywords=("review", "feedback", "comment", "comments", "upload", "publish", "resolve", "shareurl"),
+        description="review project/version upload, comments, and resolve loop",
+    ),
+    Subskill(
+        name="test",
+        owner="testboat",
+        reference="skills/test.md",
+        keywords=("test", "qa", "regression", "acceptance", "smoke", "verify", "coverage", "check"),
+        description="tests, QA, regression checks, and acceptance evidence",
+    ),
+)
+
+_SUBSKILL_BY_NAME = {subskill.name: subskill for subskill in SUBSKILLS}
+_TOKEN_PATTERN = re.compile(r"[a-z0-9#+.-]+")
+_WORKFLOW_ORDER = {
+    "context": 0,
+    "prototype": 10,
+    "presentation": 10,
+    "test": 20,
+    "review": 30,
+}
+
+
+def list_subskills() -> tuple[Subskill, ...]:
+    """Return supported subskills in route priority order."""
+    return SUBSKILLS
+
+
+def get_subskill(name: str) -> Subskill:
+    """Return a subskill by name."""
+    try:
+        return _SUBSKILL_BY_NAME[name]
+    except KeyError as exc:
+        raise ValueError(f"Unknown Mahu subskill: {name}") from exc
+
+
+def route_request(request: str) -> RouteResult:
+    """Classify a user request into a Mahu subskill sequence."""
+    cleaned = request.strip()
+    if not cleaned:
+        raise ValueError("Request cannot be empty.")
+    normalized = cleaned.lower()
+    tokens = set(_TOKEN_PATTERN.findall(normalized))
+    scores = _score(tokens, normalized)
+    matched = [name for name, score in scores.items() if score > 0]
+
+    if not matched:
+        fallback = get_subskill("context")
+        return RouteResult(
+            request=cleaned,
+            primary=fallback.name,
+            sequence=(fallback.name,),
+            references=(fallback.reference,),
+            confidence="low",
+            reason="No domain keywords matched; start by clarifying and capturing context.",
+        )
+
+    sequence = tuple(sorted(matched, key=lambda name: _workflow_priority(name)))
+    primary = sequence[0]
+    confidence = "high" if len(sequence) > 1 or scores[primary] >= 2 else "medium"
+    references = tuple(get_subskill(name).reference for name in sequence)
+    reason = _reason(sequence, scores)
+    return RouteResult(cleaned, primary, sequence, references, confidence, reason)
+
+
+def _score(tokens: set[str], normalized: str) -> dict[str, int]:
+    scores: dict[str, int] = {}
+    for subskill in SUBSKILLS:
+        score = 0
+        for keyword in subskill.keywords:
+            if keyword in tokens or (len(keyword) > 3 and keyword in normalized):
+                score += 1
+        scores[subskill.name] = score
+    return scores
+
+
+def _workflow_priority(name: str) -> int:
+    return _WORKFLOW_ORDER.get(name, len(_WORKFLOW_ORDER))  # pragma: no cover - only known subskills are ranked
+
+
+def _reason(sequence: tuple[str, ...], scores: dict[str, int]) -> str:
+    if len(sequence) == 1:
+        subskill = get_subskill(sequence[0])
+        return f"Matched {subskill.name} keywords; load {subskill.reference}."
+    route = " -> ".join(sequence)
+    detail = ", ".join(f"{name}:{scores[name]}" for name in sequence)
+    return f"Multi-intent request; execute in sequence {route}. Scores: {detail}."

mahu-1.0.0.dist-info/METADATA

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: mahu
+Version: 1.0.0
+Summary: Agent skill router for context, prototypes, presentations, tests, and feedback loops
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.1
+Provides-Extra: test
+Requires-Dist: pytest>=8.0; extra == "test"
+Requires-Dist: pytest-cov>=5.0; extra == "test"
+Dynamic: license-file
+
+# Mahu
+
+<p align="center">
+  <img src="mahu.png" alt="Mahu" width="320">
+</p>
+
+```text
+I'm Mahu, your free AI work buddy for context, prototypes, tests, feedback, and growth.
+Bring me into your daily workflow.
+```
+
+Mahu is not a single builder and not another chat persona. It is a lightweight
+agent skill package that helps Codex, OpenCode, Copilot, WorkBuddy, and future
+agents work through the right SOP instead of improvising every time.
+
+Use `/mahu` when daily work needs structure: capture context, build a prototype,
+create a presentation, test the result, publish it for feedback, or turn the
+learning loop into growth momentum.
+
+## What Mahu Helps With
+
+| User intent | Mahu subskill | Owning tool |
+| --- | --- | --- |
+| context, memory, topics, requirements | `context` | `fcontext` |
+| prototype, UI, website, app, design system | `prototype` | `fdesign` |
+| deck, PPT, slides, presentation | `presentation` | `fppt` |
+| review, feedback, comments, upload, resolve | `review` | `floop-client` |
+| tests, QA, regression, acceptance | `test` | `testboat` |
+| growth, iteration, learning loop | combine context, test, and feedback | Mahu SOP |
+
+## Install By GitHub Link
+
+The simplest install path is the same shape as `frontend-slides`: send your
+agent the GitHub repo link and ask it to use Mahu.
+
+The agent should:
+
+1. Read top-level `SKILL.md`.
+2. Classify the request.
+3. Load only the referenced file under `skills/` that matches the request.
+4. Follow that subskill SOP.
+
+## Local CLI
+
+```bash
+mahu route "make a product prototype and upload for review"
+mahu doctor --subskill prototype
+mahu validate
+mahu enable opencode --target .
+```
+
+Each Mahu subskill declares its own dependency. Before executing a routed
+subskill, run `mahu doctor --subskill <name>` or check the required CLI
+directly.
+
+| Subskill | Required CLI | Typical install |
+| --- | --- | --- |
+| `context` | `fcontext` | `pip install fcontext` |
+| `prototype` | `fdesign` | `pip install fdesign` |
+| `presentation` | `fppt` | `pip install fppt` |
+| `review` | `floop` | `pip install floop` |
+| `test` | `testboat` | `pip install testboat` |
+
+Supported enable targets:
+
+- `codex`
+- `workbuddy`
+- `copilot`
+- `opencode`
+
+## Development
+
+```bash
+PYTHONPATH=src pytest --cov=mahu --cov-report=term-missing --cov-fail-under=100
+```

mahu-1.0.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+mahu/__init__.py,sha256=ZB-Q6TWxYjJLPv_MflPJCqU7Te8Av9Isbhxo2sVYK_g,248
+mahu/cli.py,sha256=dipTD9J7VJOJiWSzdWJREDJyEQNO1CW5cbB0XwMEOpY,4291
+mahu/dependencies.py,sha256=T87HO64ACYvgkDKPo1H9wQ84XPk4W7paZMMar_CfirE,3485
+mahu/enable.py,sha256=1CJY4oqIgWOcYAwmKQuqRPZztusyderEfU1_3cR-M1s,3883
+mahu/manifest.py,sha256=LB1g7ADz3LAZzFs3GHCjPkFYVADKD4an_QsX2IL2nYM,2218
+mahu/router.py,sha256=tSroWO_F12EYNHl0EfFVRE1qErSHspYr8g-R2GcylzE,4944
+mahu-1.0.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+mahu-1.0.0.dist-info/METADATA,sha256=5XpldiI8ya7364SumCJpC3IhFhdTxlAFjQV_41iOCls,2724
+mahu-1.0.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+mahu-1.0.0.dist-info/entry_points.txt,sha256=pii9BHRarS48iU-L9dETZNIXUtzX3Gh6dwy7GfVBVN0,39
+mahu-1.0.0.dist-info/scm_file_list.json,sha256=NNJrNOAqJfL1Cns0WjRJkxsZeyryphwNIp_RCMw7_JM,799
+mahu-1.0.0.dist-info/scm_version.json,sha256=wj2tt_yEHORA7jDjKute4-msKJeQ_NWP03LyV_Uivbk,160
+mahu-1.0.0.dist-info/top_level.txt,sha256=Cf0WyM7eMWVQ9kJqOTltperSEmQ35HlBX6EuuRMdavk,5
+mahu-1.0.0.dist-info/RECORD,,

mahu-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mahu-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mahu = mahu.cli:main

mahu-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

mahu-1.0.0.dist-info/scm_file_list.json

@@ -0,0 +1,34 @@
+{
+  "files": [
+    "mahu.png",
+    "SKILL.md",
+    "README.md",
+    "LICENSE",
+    "pyproject.toml",
+    ".gitignore",
+    "src/mahu/dependencies.py",
+    "src/mahu/__init__.py",
+    "src/mahu/manifest.py",
+    "src/mahu/enable.py",
+    "src/mahu/router.py",
+    "src/mahu/cli.py",
+    "adapters/workbuddy.md",
+    "adapters/copilot.md",
+    "adapters/codex.md",
+    "adapters/opencode.md",
+    "skills/test.md",
+    "skills/review.md",
+    "skills/context.md",
+    "skills/presentation.md",
+    "skills/prototype.md",
+    "tests/test_dependencies.py",
+    "tests/__init__.py",
+    "tests/test_router.py",
+    "tests/test_manifest.py",
+    "tests/test_enable.py",
+    "tests/test_cli.py",
+    ".claude-plugin/plugin.json",
+    ".github/workflows/release.yml",
+    ".github/workflows/cicd.yml"
+  ]
+}

mahu-1.0.0.dist-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "1.0.0",
+  "distance": 0,
+  "node": "g73629b62d60f77fccfe6b73193173227e4538eda",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-07-05"
+}

mahu-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+mahu