tylor-mcp 1.0.0

package/registry.json

@@ -0,0 +1,26 @@
+{
+  "version": "1.0",
+  "skills": [
+    {
+      "name": "bmad",
+      "trigger": "Use when the user wants to create a PRD, review stories, or run BMAD workflows.",
+      "trigger_description": "Use when the user wants to create a PRD, review stories, or run BMAD workflows.",
+      "keywords": [
+        "bmad",
+        "create",
+        "prd",
+        "review",
+        "stories",
+        "workflows"
+      ],
+      "tool_count": 1,
+      "installed_date": "2026-05-13",
+      "source_path": "skills/bmad",
+      "module": "server.tools.ecc.web",
+      "tools": [
+        "web_fetch",
+        "web_scrape"
+      ]
+    }
+  ]
+}

package/server/.env.example

@@ -0,0 +1,24 @@
+# Copy this file to server/.env and fill in your values
+# Required only for Personal (DynamoDB) storage mode
+# Project JSON mode works with zero configuration
+
+# AWS — required for DynamoDB/S3/OpenSearch/Bedrock
+AWS_REGION=us-east-1
+AWS_ACCESS_KEY_ID=
+AWS_SECRET_ACCESS_KEY=
+AWS_PROFILE=                     # optional: use named AWS profile instead of keys
+
+# DynamoDB table names (created by install.sh)
+DYNAMO_TABLE=agent101
+
+# Bedrock model IDs
+BEDROCK_REGION=us-east-1
+BEDROCK_OPUS_MODEL=us.anthropic.claude-opus-4-7-20251101-v1:0
+
+# OpenSearch (optional — enables semantic memory recall)
+OPENSEARCH_HOST=
+OPENSEARCH_PORT=9200
+OPENSEARCH_INDEX=agent-memories
+
+# Token overflow fallback (optional)
+ANTHROPIC_PLATFORM_AWS_API_KEY=

package/server/config.py

@@ -0,0 +1,89 @@
+"""
+server/config.py — Agent101 server configuration.
+Reads AWS profile, Bedrock region, and Platform on AWS key.
+Resolution order: env var → ~/.agent101/config.json → .env file → defaults.
+Warns on missing optional config; never crashes on startup.
+"""
+from __future__ import annotations
+import json
+import logging
+import os
+from pathlib import Path
+
+try:
+    from dotenv import load_dotenv
+    load_dotenv(Path(__file__).parent / ".env")
+except ImportError:
+    pass  # python-dotenv optional at import time; already in requirements.txt
+
+logger = logging.getLogger(__name__)
+
+CONFIG_PATH = Path.home() / ".agent101" / "config.json"
+
+
+def _load_file_config() -> dict:
+    if CONFIG_PATH.exists():
+        try:
+            with open(CONFIG_PATH) as f:
+                data = json.load(f)
+            if not isinstance(data, dict):
+                logger.warning("~/.agent101/config.json is not a JSON object — ignoring")
+                return {}
+            return data
+        except (json.JSONDecodeError, OSError):
+            logger.warning("~/.agent101/config.json is malformed — ignoring")
+    return {}
+
+
+def _load() -> dict:
+    file_cfg = _load_file_config()
+
+    def _get(env_key: str, file_key: str | None = None, default: str | None = None) -> str | None:
+        env_val = os.environ.get(env_key)
+        if env_val is not None:
+            return env_val or None
+        return file_cfg.get(file_key or env_key) or default
+
+    def _get_any(env_keys: tuple[str, ...], default: str | None = None) -> str | None:
+        for env_key in env_keys:
+            env_val = os.environ.get(env_key)
+            if env_val is not None:
+                return env_val or None
+            file_val = file_cfg.get(env_key)
+            if file_val:
+                return file_val
+        return default
+
+    cfg = {
+        "aws_profile":       _get("AWS_PROFILE"),
+        "aws_access_key_id": _get("AWS_ACCESS_KEY_ID"),
+        "bedrock_region": _get("BEDROCK_REGION", default="us-east-1"),
+        "bedrock_opus_model": _get(
+            "BEDROCK_OPUS_MODEL",
+            default="us.anthropic.claude-opus-4-7-20251101-v1:0",
+        ),
+        "platform_key":   _get_any(("ANTHROPIC_PLATFORM_AWS_API_KEY", "ANTHROPIC_AWS_API_KEY")),
+        "platform_base_url": _get("ANTHROPIC_AWS_BASE_URL"),
+        "platform_workspace_id": _get("ANTHROPIC_AWS_WORKSPACE_ID"),
+        "dynamo_table":   _get("DYNAMO_TABLE", default="agent101"),
+        "s3_bucket":      _get("S3_BUCKET"),
+        "opensearch_host": _get("OPENSEARCH_HOST"),
+        "opensearch_port": _get("OPENSEARCH_PORT", default="9200"),
+    }
+
+    # Warn on optional keys that affect runtime features
+    if not cfg["platform_key"]:
+        logger.warning(
+            "ANTHROPIC_PLATFORM_AWS_API_KEY/ANTHROPIC_AWS_API_KEY not set — "
+            "token overflow fallback to Claude Platform on AWS is disabled"
+        )
+    if not cfg["opensearch_host"]:
+        logger.warning(
+            "OPENSEARCH_HOST not set — "
+            "semantic memory recall (recall_memory) will be unavailable until configured"
+        )
+
+    return cfg
+
+
+config = _load()

package/server/main.py

@@ -0,0 +1,93 @@
+"""
+server/main.py — agent101 FastMCP entry point.
+
+Starts both FastMCP (stdio transport) and the aiohttp Thread Visualizer
+server concurrently on a single asyncio event loop.
+
+Can be run as a script: python3 server/main.py (from the plugin root)
+or as a module: python3 -m server.main
+"""
+from __future__ import annotations
+import asyncio
+import logging
+import os
+import signal
+import sys
+
+# Allow running as a standalone script OR as a module.
+# When run as `python3 server/main.py`, __package__ is None and relative
+# imports fail. This block ensures the plugin root is on sys.path so that
+# `from server.tools...` absolute imports work in both modes.
+if __package__ is None or __package__ == "":
+    _plugin_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    if _plugin_root not in sys.path:
+        sys.path.insert(0, _plugin_root)
+
+from server.tools._mcp import mcp  # noqa: F401
+
+# Register @mcp.tool() decorators (side effects)
+from server.tools import tylor          # noqa: F401
+from server.tools import agents         # noqa: F401
+from server.tools import registry       # noqa: F401
+from server.tools import skill_installer  # noqa: F401
+from server.tools import help           # noqa: F401
+from server.tools import executor       # noqa: F401
+from server.tools import ui             # noqa: F401
+from server.tools import harness        # noqa: F401  — Agent SDK orchestration
+from server import config               # noqa: F401
+
+logger = logging.getLogger(__name__)
+
+
+async def _main(ui_only: bool = False) -> None:
+    from server.ui_server import start_ui_server
+
+    runner = await start_ui_server()
+
+    from server.ui_server import ui_available
+    if not ui_available:
+        print(
+            "Thread UI could not start (port 8765 in use) — MCP tools unaffected",
+            file=sys.stderr,
+        )
+
+    loop = asyncio.get_running_loop()
+    stop_event = asyncio.Event()
+
+    def _signal_handler() -> None:
+        stop_event.set()
+
+    for sig in (signal.SIGINT, signal.SIGTERM):
+        try:
+            loop.add_signal_handler(sig, _signal_handler)
+        except NotImplementedError:
+            pass
+
+    if ui_only:
+        logger.info("Running in UI-only mode — http://localhost:8765")
+        await stop_event.wait()
+    else:
+        mcp_task = asyncio.create_task(mcp.run_stdio_async())
+        stop_task = asyncio.create_task(stop_event.wait())
+        done, pending = await asyncio.wait(
+            [mcp_task, stop_task],
+            return_when=asyncio.FIRST_COMPLETED,
+        )
+        for task in pending:
+            task.cancel()
+            try:
+                await task
+            except (asyncio.CancelledError, Exception):
+                pass
+
+    if runner is not None:
+        await runner.cleanup()
+
+
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--ui-only', action='store_true',
+                        help='Run only the aiohttp visualizer server (no MCP stdio)')
+    args = parser.parse_args()
+    asyncio.run(_main(ui_only=args.ui_only))

package/server/personas/analyst.md

@@ -0,0 +1,15 @@
+# Analyst
+
+## Role Description
+
+Research and analysis specialist focused on market context, competitive comparison, evidence synthesis, and decision support.
+
+## Communication Style
+
+Structured, evidence-oriented, and concise. Separates facts, assumptions, and recommendations.
+
+## ECC Tool Categories
+
+- `ecc/web`
+- `ecc/data`
+- `ecc/diagrams`

package/server/personas/ceo.md

@@ -0,0 +1,14 @@
+# CEO
+
+## Role Description
+
+Strategic executive persona focused on business direction, prioritization, stakeholder framing, and high-leverage product decisions.
+
+## Communication Style
+
+Outcome-driven, decisive, and clear. Frames tradeoffs in terms of impact, risk, and sequencing.
+
+## ECC Tool Categories
+
+- `ecc/presentation`
+- `ecc/web`

package/server/personas/code_agent.md

@@ -0,0 +1,15 @@
+# Code Agent
+
+## Role Description
+
+Senior implementation engineer focused on shipping correct code, tests, and maintainable technical changes inside the active thread scope.
+
+## Communication Style
+
+Direct, concrete, and implementation-first. States assumptions, changed files, validation commands, and residual risks.
+
+## ECC Tool Categories
+
+- `ecc/web`
+- `ecc/data`
+- `ecc/pipeline`

package/server/personas/cto.md

@@ -0,0 +1,14 @@
+# CTO
+
+## Role Description
+
+Technical leadership persona focused on architecture, systems tradeoffs, delivery risk, platform strategy, and engineering standards.
+
+## Communication Style
+
+Pragmatic, precise, and systems-minded. Connects technical choices to constraints, failure modes, and maintainability.
+
+## ECC Tool Categories
+
+- `ecc/diagrams`
+- `ecc/pipeline`

package/server/provision.py

@@ -0,0 +1,260 @@
+"""
+Story 1.3: DynamoDB Table & S3 Bucket Provisioning
+Each provision_*() returns (passed: bool, message: str).
+run_all() prints results and returns the count of provisioning errors.
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+
+
+# ---------------------------------------------------------------------------
+# Colour helpers (same as validate.py)
+# ---------------------------------------------------------------------------
+GREEN  = "\033[0;32m"
+RED    = "\033[0;31m"
+YELLOW = "\033[1;33m"
+NC     = "\033[0m"
+
+def _ok(msg: str) -> str:
+    return f"  {GREEN}✓{NC}  {msg}"
+
+def _fail(msg: str) -> str:
+    return f"  {RED}✗{NC}  {msg}"
+
+def _warn(msg: str) -> str:
+    return f"  {YELLOW}⚠{NC}   {msg}"
+
+
+# ---------------------------------------------------------------------------
+# Config resolution
+# ---------------------------------------------------------------------------
+
+def _resolve_config(plugin_dir: str = "") -> dict:
+    """
+    Resolve provisioning config.
+    Priority: ~/.agent101/config.json → env vars → defaults.
+    Default bucket name derived from AWS account ID (guarantees global uniqueness).
+    """
+    config_path = Path.home() / ".agent101" / "config.json"
+    file_config: dict = {}
+    if config_path.exists():
+        try:
+            file_config = json.loads(config_path.read_text())
+        except (json.JSONDecodeError, OSError):
+            pass
+
+    table_name = (
+        file_config.get("DYNAMO_TABLE")
+        or os.environ.get("DYNAMO_TABLE", "")
+        or "agent101"
+    )
+
+    region = (
+        file_config.get("AWS_REGION")
+        or os.environ.get("AWS_REGION")
+        or os.environ.get("AWS_DEFAULT_REGION", "")
+        or "us-east-1"
+    )
+
+    # Bucket name: config → env → default using account ID
+    bucket_name = file_config.get("S3_BUCKET") or os.environ.get("S3_BUCKET", "")
+    if not bucket_name:
+        try:
+            import boto3  # noqa: PLC0415
+            account_id = boto3.client("sts").get_caller_identity()["Account"]
+            bucket_name = f"agent101-blobs-{account_id}"
+        except Exception:  # noqa: BLE001
+            bucket_name = "agent101-blobs"
+
+    return {"table_name": table_name, "bucket_name": bucket_name, "region": region}
+
+
+# ---------------------------------------------------------------------------
+# DynamoDB provisioning
+# ---------------------------------------------------------------------------
+
+def provision_dynamodb(table_name: str) -> tuple[bool, str]:
+    """
+    Create DynamoDB table if absent (PAY_PER_REQUEST, PK+SK, PITR).
+    Skip + validate schema if present.
+    """
+    try:
+        import boto3  # noqa: PLC0415
+        from botocore.exceptions import ClientError  # noqa: PLC0415
+
+        client = boto3.client("dynamodb")
+
+        # Check if table already exists
+        try:
+            response = client.describe_table(TableName=table_name)
+            # Validate schema compatibility
+            key_attrs = {k["AttributeName"] for k in response["Table"]["KeySchema"]}
+            if {"PK", "SK"}.issubset(key_attrs):
+                # Ensure PITR is enabled even on pre-existing tables
+                pitr = client.describe_continuous_backups(TableName=table_name)
+                pitr_status = (
+                    pitr["ContinuousBackupsDescription"]
+                    ["PointInTimeRecoveryDescription"]
+                    ["PointInTimeRecoveryStatus"]
+                )
+                if pitr_status != "ENABLED":
+                    client.update_continuous_backups(
+                        TableName=table_name,
+                        PointInTimeRecoverySpecification={"PointInTimeRecoveryEnabled": True},
+                    )
+                return True, _ok(f"DynamoDB table '{table_name}' already exists — skipping")
+            else:
+                return True, _warn(
+                    f"DynamoDB table '{table_name}' exists but schema is incompatible "
+                    f"(found keys: {key_attrs}). agent101 requires PK+SK. "
+                    "Proceeding — rename the table in ~/.agent101/config.json if needed."
+                )
+        except ClientError as e:
+            if e.response["Error"]["Code"] != "ResourceNotFoundException":
+                raise
+
+        # Table does not exist — create it
+        client.create_table(
+            TableName=table_name,
+            KeySchema=[
+                {"AttributeName": "PK", "KeyType": "HASH"},
+                {"AttributeName": "SK", "KeyType": "RANGE"},
+            ],
+            AttributeDefinitions=[
+                {"AttributeName": "PK", "AttributeType": "S"},
+                {"AttributeName": "SK", "AttributeType": "S"},
+            ],
+            BillingMode="PAY_PER_REQUEST",
+        )
+
+        # Wait for ACTIVE state before enabling PITR
+        waiter = client.get_waiter("table_exists")
+        waiter.wait(
+            TableName=table_name,
+            WaiterConfig={"Delay": 2, "MaxAttempts": 20},
+        )
+
+        # PITR may not be available immediately after ACTIVE — retry up to 5×
+        import time  # noqa: PLC0415
+        for attempt in range(5):
+            try:
+                client.update_continuous_backups(
+                    TableName=table_name,
+                    PointInTimeRecoverySpecification={"PointInTimeRecoveryEnabled": True},
+                )
+                break
+            except ClientError as e:
+                if e.response["Error"]["Code"] == "ContinuousBackupsUnavailableException" and attempt < 4:
+                    time.sleep(3)
+                else:
+                    raise
+
+        return True, _ok(f"DynamoDB table '{table_name}' created")
+
+    except ImportError:
+        return False, _fail("DynamoDB provisioning — boto3 not installed")
+    except Exception as exc:  # noqa: BLE001
+        return False, _fail(f"DynamoDB provisioning failed — {exc}\n     Fix: check IAM permissions (dynamodb:CreateTable, dynamodb:UpdateContinuousBackups)")
+
+
+# ---------------------------------------------------------------------------
+# S3 provisioning
+# ---------------------------------------------------------------------------
+
+def provision_s3(bucket_name: str, region: str = "us-east-1") -> tuple[bool, str]:
+    """
+    Create S3 bucket if absent with private ACL + block public access.
+    Skip if already owned by this account.
+    NOTE: us-east-1 must NOT pass CreateBucketConfiguration (boto3 quirk).
+    """
+    try:
+        import boto3  # noqa: PLC0415
+        from botocore.exceptions import ClientError  # noqa: PLC0415
+
+        client = boto3.client("s3", region_name=region)
+
+        try:
+            if region == "us-east-1":
+                client.create_bucket(Bucket=bucket_name)
+            else:
+                client.create_bucket(
+                    Bucket=bucket_name,
+                    CreateBucketConfiguration={"LocationConstraint": region},
+                )
+
+            # Block all public access (security baseline)
+            client.put_public_access_block(
+                Bucket=bucket_name,
+                PublicAccessBlockConfiguration={
+                    "BlockPublicAcls": True,
+                    "IgnorePublicAcls": True,
+                    "BlockPublicPolicy": True,
+                    "RestrictPublicBuckets": True,
+                },
+            )
+            return True, _ok(f"S3 bucket '{bucket_name}' created")
+
+        except ClientError as e:
+            code = e.response["Error"]["Code"]
+            if code == "BucketAlreadyOwnedByYou":
+                return True, _ok(f"S3 bucket '{bucket_name}' already exists — skipping")
+            if code == "BucketAlreadyExists":
+                return False, _fail(
+                    f"S3 bucket '{bucket_name}' already exists and is owned by another account.\n"
+                    "     Fix: set a unique S3_BUCKET name in ~/.agent101/config.json"
+                )
+            raise
+
+    except ImportError:
+        return False, _fail("S3 provisioning — boto3 not installed")
+    except Exception as exc:  # noqa: BLE001
+        return False, _fail(f"S3 provisioning failed — {exc}\n     Fix: check IAM permissions (s3:CreateBucket, s3:PutPublicAccessBlock)")
+
+
+# ---------------------------------------------------------------------------
+# run_all — called by install.sh
+# ---------------------------------------------------------------------------
+
+def run_all(plugin_dir: str = "") -> int:
+    """
+    Provision all AWS resources, print results, return error count.
+    Caller (install.sh) always exits 0 — this is advisory.
+    """
+    print(f"\n\033[1mProvisioning AWS resources\033[0m")
+
+    config = _resolve_config(plugin_dir)
+    errors = 0
+
+    passed, msg = provision_dynamodb(config["table_name"])
+    print(msg)
+    if not passed:
+        errors += 1
+
+    passed, msg = provision_s3(config["bucket_name"], config["region"])
+    print(msg)
+    if not passed:
+        errors += 1
+
+    if errors > 0:
+        print(
+            f"\n  {YELLOW}⚠{NC}   Provisioning: {errors} resource(s) failed. "
+            "Personal mode features require DynamoDB + S3.\n"
+            "     Fix the errors above then re-run ./install.sh"
+        )
+
+    return errors
+
+
+# ---------------------------------------------------------------------------
+# Entry point — called by install.sh as:
+#   python3 "$PLUGIN_DIR/server/provision.py" "$PLUGIN_DIR"
+# Always exits 0 (advisory).
+# ---------------------------------------------------------------------------
+if __name__ == "__main__":
+    plugin_dir = sys.argv[1] if len(sys.argv) > 1 else ""
+    run_all(plugin_dir)
+    sys.exit(0)