用 AgentCore 把代码自动做成架构图

def scan_codebase(source_path: str) -> str:
    """Scan .NET codebase and return structured analysis."""
    cs_files = []
    for root, dirs, files in os.walk(source_path):
        dirs[:] = [d for d in dirs if d not in ['bin', 'obj', 'packages', '.git']]
        for file in files:
            if file.endswith('.cs'):
                analysis = analyze_csharp_file(os.path.join(root, file))
                cs_files.append(analysis)
    return json.dumps({
        "files_found": len(cs_files),
        "summary": generate_summary(cs_files),
        "files": cs_files
    })

from bedrock_agentcore.runtime import BedrockAgentCoreApp
from strands import Agent
from strands.models.bedrock import BedrockModel

app = BedrockAgentCoreApp()

def create_uml_agent():
    model = BedrockModel(
        model_id="your-selected-model-id",
        region_name="us-east-1",
        temperature=0.3,
        max_tokens=4096
    )
    agent = Agent(
        model=model,
        system_prompt=UML_GENERATION_PROMPT,
        tools=[fetch_source_from_s3, scan_codebase, save_mermaid_diagram,\
               validate_mermaid_syntax, convert_to_svg, upload_to_s3]
    )
    return agent

@app.entrypoint
async def invoke(payload: Dict[str, Any], context: Any) -> AsyncGenerator[Dict[str, Any], None]:
    """AgentCore entrypoint for UML generation."""
    # Extract parameters from payload
    source_s3_bucket = payload.get("source_s3_bucket")
    source_s3_key = payload.get("source_s3_key")
    project_name = payload.get("project_name", "Project")
    diagrams_bucket = payload.get("diagrams_bucket", "")

    # Create UML agent instance
    agent = create_uml_agent()

    # Construct generation prompt
    generation_prompt = f"""Generate complete UML documentation for {project_name}.

Steps:
1. Fetch source code from Amazon S3 bucket: {source_s3_bucket}, key: {source_s3_key}
2. Scan and analyze the codebase
3. Generate all required diagrams
4. Validate and convert each diagram to SVG
5. Upload all artifacts to Amazon S3

Begin now by fetching the source code."""

    # Stream async response
    stream = agent.stream_async(generation_prompt)

    # Process stream events
    async for event in stream:
        if "data" in event and isinstance(event["data"], str):
            yield {"content": event["data"]}

version: 0.2

env:
  variables:
    SOURCE_BUCKET: "amzn-s3-demo-source-bucket1"
    DOCS_BUCKET: "amzn-s3-demo-source-bucket2"
    VECTOR_STORE_BUCKET: "amzn-s3-demo-destination-bucket"
    AGENT_ID: "agentcore-uml-agent"
    PROJECT_NAME: "MyDotNetService"
    KB_ID: "architecture-diagrams-kb"
    DATA_SOURCE_ID: "architecture-diagrams-source"
    AWS_REGION: "us-east-1"

phases:
  install:
    runtime-versions:
      python: 3.11
    commands:
      - pip install boto3 awscli
  pre_build:
    commands:
      # Package source code
      - zip -r source_code.zip src/
      # Upload to S3 for agent access
      - aws s3 cp source_code.zip s3://${SOURCE_BUCKET}/source_code.zip
  build:
    commands:
      # Invoke AgentCore agent - generates SVG, Mermaid, and metadata JSON
      - |
        python invoke_agentcore.py \
          --agent-id ${AGENT_ID} \
          --project-name ${PROJECT_NAME} \
          --s3-bucket ${SOURCE_BUCKET} \
          --s3-key source_code.zip \
          --output-dir uml_output \
          --region ${AWS_REGION}
      # Verify expected output structure before publishing
      - |
        echo "Verifying output structure..."
        ls -R uml_output/
        test -d uml_output/svg && echo "SVG directory found"
        test -d uml_output/mermaid && echo "Mermaid directory found"
        test -d uml_output/metadata && echo "Metadata directory found"
  post_build:
    commands:
      # Sync each artifact type independently to preserve structure
      # Using --size-only to avoid unnecessary overwrites on unchanged files
      - aws s3 sync uml_output/svg/ s3://${DOCS_BUCKET}/svg/ --size-only
      - aws s3 sync uml_output/mermaid/ s3://${DOCS_BUCKET}/mermaid/ --size-only
      - aws s3 sync uml_output/metadata/ s3://${DOCS_BUCKET}/metadata/ --size-only
      # Wait for S3 eventual consistency before triggering ingestion
      - sleep 5
      # Trigger Amazon Bedrock Knowledge Bases ingestion after all files are uploaded
      - |
        python trigger_kb_sync.py \
          --knowledge-base-id ${KB_ID} \
          --data-source-id ${DATA_SOURCE_ID} \
          --region ${AWS_REGION}

artifacts:
  files:
    - uml_output/**/*

{
  "diagram_type": "sequence",
  "title": "Message Publishing Flow",
  "description": "End-to-end message publishing sequence including connection establishment, channel creation, and broker confirmation.",
  "entities": ["Publisher", "ConnectionManager", "Channel", "RabbitMQ Broker"],
  "mermaid_source": "sequenceDiagram\n Publisher->>ConnectionManager: GetConnection()...",
  "svg_s3_uri": "s3://amzn-s3-demo-source-bucket2/svg/3-sequence-diagram-publish.svg",
  "source_repository": "my-dotnet-service",
  "generated_at": "2025-01-15T10:30:00Z"
}