amonhen-code 0.1.0__tar.gz

amonhen_code-0.1.0/.gitignore

@@ -0,0 +1,50 @@
+# Python bytecode
+__pycache__/
+*.pyc
+
+# Virtual environments
+.venv/
+.venv-*/
+
+# Environment variables
+.env
+
+# OS files
+.DS_Store
+
+# Editor settings
+.vscode/
+.claude/
+CLAUDE.md
+backup.sh
+
+# VSCode extension (has its own build artifacts / node_modules)
+vscode-amonhen/
+
+# Large / Box-synced plan docs (track manually when needed)
+docs/AmonHen_VSCode_Extension_Project_Plan.md
+docs/AmonHen_iOS_App_Project_Plan.pdf
+docs/ios-app-project-plan.md
+docs/Amon Hen - Delivery Mechanisms.md
+docs/AmonHen-Brand-System-v1.md
+docs/AmonHen-NDA-and-IP-Assignment-Agreement.md
+docs/architecture/amonhen-db-flow.html
+
+# SQLite databases
+*.db
+
+# Large PDF audit reports
+docs/AmonHen_Enterprise_Readiness_Audit_*.pdf
+
+# Uploaded documents (local filesystem storage)
+document_storage/
+!document_storage/.gitkeep
+
+# iOS app – source tracked; build artifacts excluded by ios/.gitignore
+
+# UI image assets not yet committed
+src/amonhen/ui/Images/amonhen_128x128.png
+
+# Local MCP server config
+.mcp.json
+mcp-server-amonhen/

amonhen_code-0.1.0/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: amonhen-code
+Version: 0.1.0
+Summary: Amon Hen Code — AI agent grounded in team knowledge
+License-Expression: MIT
+Requires-Python: >=3.10
+Requires-Dist: claude-agent-sdk>=0.1.40
+Requires-Dist: click>=8.0
+Requires-Dist: mcp-server-amonhen>=0.1.0
+Requires-Dist: rich>=13.0
+Description-Content-Type: text/plain
+
+Amon Hen Code — AI agent grounded in team knowledge.

amonhen_code-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "amonhen-code"
+version = "0.1.0"
+description = "Amon Hen Code — AI agent grounded in team knowledge"
+readme = {text = "Amon Hen Code — AI agent grounded in team knowledge.", content-type = "text/plain"}
+requires-python = ">=3.10"
+license = "MIT"
+dependencies = [
+    "claude-agent-sdk>=0.1.40",
+    "mcp-server-amonhen>=0.1.0",
+    "click>=8.0",
+    "rich>=13.0",
+]
+
+[project.scripts]
+amonhen-code = "amonhen_code.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/amonhen_code"]

amonhen_code-0.1.0/src/amonhen_code/__init__.py

@@ -0,0 +1,8 @@
+# Confidential and Proprietary
+# Copyright (c) 2024-2026 AmonHen AI.
+# All rights reserved.
+# Unauthorized copying or distribution is strictly prohibited.
+
+"""Amon Hen Code — AI agent grounded in team knowledge."""
+
+__version__ = "0.1.0"

amonhen_code-0.1.0/src/amonhen_code/agents/__init__.py

@@ -0,0 +1,5 @@
+# Confidential and Proprietary
+# Copyright (c) 2024-2026 AmonHen AI.
+# All rights reserved.
+# Unauthorized copying or distribution is strictly prohibited.
+

amonhen_code-0.1.0/src/amonhen_code/agents/grounded.py

@@ -0,0 +1,99 @@
+# Confidential and Proprietary
+# Copyright (c) 2024-2026 AmonHen AI.
+# All rights reserved.
+# Unauthorized copying or distribution is strictly prohibited.
+
+"""Grounded Code Agent -- modify code while enforcing Amon Hen project rules."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from claude_agent_sdk import (
+    AssistantMessage,
+    HookMatcher,
+    ClaudeAgentOptions,
+    ResultMessage,
+    TextBlock,
+    query,
+)
+from rich.console import Console
+
+from amonhen_code.context import fetch_project_context, format_context_for_prompt
+from amonhen_code.hooks import enforce_rules_on_write, track_file_changes
+from amonhen_code.prompts import GROUNDED_CODE
+from amonhen_code.tools import build_amonhen_server
+
+console = Console()
+
+
+async def run_grounded_agent(
+    *,
+    project_id: str,
+    cwd: str = ".",
+    max_turns: int | None = None,
+    task: str | None = None,
+) -> None:
+    """Launch the Grounded Code Agent."""
+
+    # 1. Fetch project context from Amon Hen (no LLM call).
+    console.print("[dim]Fetching project context from Amon Hen...[/dim]")
+    context_result = await fetch_project_context(project_id)
+    context_block = format_context_for_prompt(context_result)
+
+    item_count = len(context_result.get("context", []))
+    console.print(f"[dim]Loaded {item_count} context items.[/dim]")
+
+    # 2. Build system prompt with injected context.
+    system_prompt = GROUNDED_CODE.format(context_block=context_block)
+
+    # 3. Build in-process MCP server for Amon Hen tools.
+    amonhen_server = build_amonhen_server()
+
+    # 4. Configure the agent.
+    prompt = task or (
+        "What would you like me to work on? "
+        "I will follow the project rules and decisions."
+    )
+
+    options = ClaudeAgentOptions(
+        system_prompt=system_prompt,
+        cwd=str(Path(cwd).resolve()),
+        permission_mode="acceptEdits",
+        max_turns=max_turns,
+        mcp_servers={"amonhen": amonhen_server},
+        allowed_tools=[
+            "Read",
+            "Write",
+            "Edit",
+            "Bash",
+            "Glob",
+            "Grep",
+            "mcp__amonhen__ask_amon_hen",
+            "mcp__amonhen__propose_context_item",
+        ],
+        hooks={
+            "PreToolUse": [
+                HookMatcher(
+                    matcher="Write|Edit",
+                    hooks=[enforce_rules_on_write],
+                ),
+            ],
+            "PostToolUse": [
+                HookMatcher(
+                    matcher="Write|Edit",
+                    hooks=[track_file_changes],
+                ),
+            ],
+        },
+    )
+
+    # 5. Run the agent.
+
+    async for message in query(prompt=prompt, options=options):
+        if isinstance(message, ResultMessage):
+            console.print(f"\n{message.result}")
+        elif isinstance(message, AssistantMessage):
+            for block in message.content:
+                if isinstance(block, TextBlock):
+                    console.print(block.text)

amonhen_code-0.1.0/src/amonhen_code/cli.py

@@ -0,0 +1,91 @@
+# Confidential and Proprietary
+# Copyright (c) 2024-2026 AmonHen AI.
+# All rights reserved.
+# Unauthorized copying or distribution is strictly prohibited.
+
+"""CLI entry point for Amon Hen Code."""
+
+import asyncio
+
+import click
+from rich.console import Console
+from rich.text import Text
+
+console = Console()
+
+_MOUNTAIN_ART = (
+    "     /\\\n"
+    "    /  \\     /\\\n"
+    "   /    \\   /  \\\n"
+    "  /      \\_/    \\\n"
+    " /________________\\"
+)
+
+
+def _print_banner() -> None:
+    console.print(Text(_MOUNTAIN_ART, style="#5E81F4"))
+    console.print("[bold]  Amon Hen Code[/bold] [dim]v0.1.0[/dim]")
+    console.print("[dim]  Clarity for Complex Projects.[/dim]\n")
+
+
+@click.group()
+@click.version_option(version="0.1.0")
+def main():
+    """Amon Hen Code -- AI agent grounded in team knowledge."""
+
+
+@main.command()
+def login():
+    """Authenticate with Amon Hen (Auth0 device flow)."""
+    from mcp_amonhen.auth import login_interactive
+
+    login_interactive()
+
+
+@main.command()
+def logout():
+    """Clear stored authentication tokens."""
+    from mcp_amonhen.auth import logout
+
+    logout()
+    console.print("[green]Logged out.[/green]")
+
+
+@main.command()
+def projects():
+    """List your Amon Hen projects."""
+    from mcp_amonhen.client import AmonHenClient
+
+    async def _list():
+        client = AmonHenClient()
+        projs = await client.list_projects()
+        if not projs:
+            console.print("[dim]No projects found.[/dim]")
+            return
+        for p in projs:
+            name = p.get("name", "?")
+            pid = p.get("id", "?")
+            count = p.get("context_count", 0)
+            console.print(f"  {name}  [dim]{pid}[/dim]  ({count} items)")
+
+    asyncio.run(_list())
+
+
+@main.command()
+@click.option("--project", "-p", required=True, help="Amon Hen project UUID")
+@click.option("--cwd", "-d", default=".", help="Working directory for the agent")
+@click.option("--max-turns", "-t", default=None, type=int, help="Maximum agent turns")
+@click.option("--task", "-m", default=None, help="Task description for the agent")
+def code(project, cwd, max_turns, task):
+    """Grounded Code Agent -- modify code while enforcing project rules."""
+    from amonhen_code.agents.grounded import run_grounded_agent
+
+    _print_banner()
+    asyncio.run(
+        run_grounded_agent(
+            project_id=project,
+            cwd=cwd,
+            max_turns=max_turns,
+            task=task,
+        )
+    )

amonhen_code-0.1.0/src/amonhen_code/context.py

@@ -0,0 +1,67 @@
+# Confidential and Proprietary
+# Copyright (c) 2024-2026 AmonHen AI.
+# All rights reserved.
+# Unauthorized copying or distribution is strictly prohibited.
+
+"""Fetch and format project context from Amon Hen for system prompt injection."""
+
+from __future__ import annotations
+
+from mcp_amonhen.client import AmonHenClient
+
+
+async def fetch_project_context(project_id: str, intent: str | None = None) -> dict:
+    """Fetch raw assembled context items via GET /v1/projects/{id}/context."""
+    client = AmonHenClient()
+    return await client.get_context(project_id, intent=intent)
+
+
+def format_context_for_prompt(context_result: dict) -> str:
+    """Format assembled context items as a structured text block for system prompt injection.
+
+    Groups items by type in priority order: rules -> decisions -> code_context -> notes.
+    """
+    items = context_result.get("context", [])
+    if not items:
+        return "(No project context items found.)"
+
+    buckets: dict[str, list[str]] = {
+        "rule": [],
+        "decision": [],
+        "code_context": [],
+        "note": [],
+    }
+
+    for item in items:
+        item_type = item.get("item_type", "note")
+        content = item.get("content", "")
+        if item_type in buckets:
+            buckets[item_type].append(content)
+
+    sections = []
+
+    if buckets["rule"]:
+        sections.append("## RULES (absolute law — must be followed)")
+        for i, r in enumerate(buckets["rule"], 1):
+            sections.append(f"{i}. {r}")
+        sections.append("")
+
+    if buckets["decision"]:
+        sections.append("## DECISIONS (committed team choices — apply, do not revisit)")
+        for i, d in enumerate(buckets["decision"], 1):
+            sections.append(f"{i}. {d}")
+        sections.append("")
+
+    if buckets["code_context"]:
+        sections.append("## CODE CONTEXT (implementation patterns)")
+        for i, c in enumerate(buckets["code_context"], 1):
+            sections.append(f"{i}. {c}")
+        sections.append("")
+
+    if buckets["note"]:
+        sections.append("## NOTES (observations and context)")
+        for i, n in enumerate(buckets["note"], 1):
+            sections.append(f"{i}. {n}")
+        sections.append("")
+
+    return "\n".join(sections)

amonhen_code-0.1.0/src/amonhen_code/hooks.py

@@ -0,0 +1,61 @@
+# Confidential and Proprietary
+# Copyright (c) 2024-2026 AmonHen AI.
+# All rights reserved.
+# Unauthorized copying or distribution is strictly prohibited.
+
+"""Agent SDK hooks for Amon Hen Code."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+# Accumulate file changes during a session for summary.
+_session_changes: list[dict[str, Any]] = []
+
+
+async def enforce_rules_on_write(
+    input_data: dict[str, Any],
+    tool_use_id: str | None,
+    context: dict[str, Any],
+) -> dict[str, Any]:
+    """PreToolUse hook: remind the agent to check rules before file writes."""
+    tool_name = input_data.get("tool_name", "")
+    if tool_name in ("Write", "Edit"):
+        return {
+            "systemMessage": (
+                "REMINDER: Before completing this file write, verify that the "
+                "content complies with all project RULES from the Amon Hen "
+                "context. If any rule is violated, modify the content to comply "
+                "before proceeding."
+            )
+        }
+    return {}
+
+
+async def track_file_changes(
+    input_data: dict[str, Any],
+    tool_use_id: str | None,
+    context: dict[str, Any],
+) -> dict[str, Any]:
+    """PostToolUse hook: track file modifications for session summary."""
+    tool_name = input_data.get("tool_name", "")
+    if tool_name in ("Write", "Edit"):
+        file_path = input_data.get("tool_input", {}).get("file_path", "unknown")
+        _session_changes.append(
+            {
+                "tool": tool_name,
+                "file_path": file_path,
+            }
+        )
+    return {}
+
+
+def get_session_changes() -> list[dict[str, Any]]:
+    """Return the accumulated file changes for this session."""
+    return list(_session_changes)
+
+
+def clear_session_changes() -> None:
+    """Reset the session change tracker."""
+    _session_changes.clear()

amonhen_code-0.1.0/src/amonhen_code/prompts.py

@@ -0,0 +1,29 @@
+# Confidential and Proprietary
+# Copyright (c) 2024-2026 AmonHen AI.
+# All rights reserved.
+# Unauthorized copying or distribution is strictly prohibited.
+
+"""System prompt templates for Amon Hen Code agent modes."""
+
+GROUNDED_CODE = """\
+You are a senior software engineer working on a codebase governed by explicit \
+team rules and decisions stored in Amon Hen.
+
+AUTHORITATIVE PROJECT CONTEXT:
+{context_block}
+
+RULES listed above are absolute law. Every code change you make MUST comply \
+with these rules. If a rule conflicts with your general knowledge, the rule wins.
+
+DECISIONS represent committed team choices. Apply them; do not revisit them \
+unless the user explicitly asks.
+
+CODE CONTEXT shows established implementation patterns. Follow them for \
+consistency.
+
+When modifying or generating code:
+1. Check every change against the project rules before writing
+2. Follow established patterns from code context items
+3. If unsure whether a change violates a rule, use the ask_amon_hen tool to verify
+4. After significant changes, briefly note which rules or decisions governed your approach
+"""

amonhen_code-0.1.0/src/amonhen_code/tools.py

@@ -0,0 +1,71 @@
+# Confidential and Proprietary
+# Copyright (c) 2024-2026 AmonHen AI.
+# All rights reserved.
+# Unauthorized copying or distribution is strictly prohibited.
+
+"""In-process SDK MCP tools for Amon Hen operations."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from claude_agent_sdk import tool, create_sdk_mcp_server
+from mcp_amonhen.client import AmonHenClient
+
+_client = AmonHenClient()
+
+
+@tool(
+    "ask_amon_hen",
+    "Ask Amon Hen for project-scoped advisory on a technical question. "
+    "Use this when you need guidance grounded in the team's rules and decisions.",
+    {"project_id": str, "question": str},
+)
+async def ask_amon_hen(args: dict[str, Any]) -> dict[str, Any]:
+    """Get advisory from Amon Hen, grounded in project context."""
+    result = await _client.advise(args["question"], args["project_id"])
+    advice = result.get("advice", "No advice returned.")
+    hints = result.get("follow_up_hints", [])
+    text = advice
+    if hints:
+        text += "\n\nFollow-up questions you might consider:\n"
+        text += "\n".join(f"- {h}" for h in hints)
+    return {"content": [{"type": "text", "text": text}]}
+
+
+@tool(
+    "propose_context_item",
+    "Propose a new rule, decision, note, or code_context item to the Amon Hen project. "
+    "Use this to capture knowledge discovered while working on the codebase.",
+    {
+        "project_id": str,
+        "item_type": str,
+        "content": str,
+        "rationale": str,
+    },
+)
+async def propose_context_item(args: dict[str, Any]) -> dict[str, Any]:
+    """Create a new context item in Amon Hen."""
+    result = await _client.create_context(
+        project_id=args["project_id"],
+        item_type=args["item_type"],
+        content=args["content"],
+        rationale=args.get("rationale"),
+    )
+    item_id = result.get("id", "unknown")
+    return {
+        "content": [
+            {
+                "type": "text",
+                "text": f"Created {args['item_type']} item (id: {item_id}).",
+            }
+        ]
+    }
+
+
+def build_amonhen_server():
+    """Create the in-process MCP server with Amon Hen tools."""
+    return create_sdk_mcp_server(
+        name="amonhen",
+        tools=[ask_amon_hen, propose_context_item],
+    )