# genpark-bio-builder

Adopt this skill: https://proskills.md/skills/other/alphaparkinc-openclaw-genpark-bio-builder

Page: https://proskills.md/skills/other/alphaparkinc-openclaw-genpark-bio-builder
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: SKILL.md
size: 1343
sha: 05c0e28e965851a42c5cbb1f2d7b7a366c716194
upstream: https://github.com/alphaparkinc/openclaw-genpark-bio-builder/blob/HEAD/SKILL.md

```text
---
name: genpark-bio-builder
description: Dynamic, AI-driven personal linking hub and affiliate conversion page.
version: 1.0.0
---

# genpark-bio-builder

## Overview
Unlike static "Link in Bio" platforms (e.g., Linktree), this skill creates a dynamic conversion interface. It helps creators generate a centralized hub where a conversational AI widget acts as a personal concierge. The assistant answers visitor questions and proactively recommends the creator's affiliate links or products based on the visitor's needs.

## Core Capabilities
- **Hub Generation**: Generate a mobile-optimized, highly aesthetic HTML/CSS page housing the creator's primary links.
- **Concierge Agent**: Deploy a specialized GenPark agent within the bio link page trained exclusively on the creator's affiliate deals.
- **Analytics Tracking**: Measure outbound click-through rates (CTR) and AI-driven conversion touches.

## Usage Guide
To build a bio page:
1. Ask the creator to list their top 5 affiliate links, products, or primary social channels.
2. Ask for a brief "knowledge base" defining what the creator represents and what each product solves.
3. Generate the Bio Hub HTML and instruct the user on how to embed the GenPark Assistant.
4. Configure the GenPark Assistant instructions to always guide relevant conversations toward the affiliate links.
```

## File: README.md
size: 2039
sha: 77666464f9a7502cca65b51665282620bcb48f9d
upstream: https://github.com/alphaparkinc/openclaw-genpark-bio-builder/blob/HEAD/README.md

````text
# openclaw-genpark-bio-builder

[![OpenClaw](https://img.shields.io/badge/OpenClaw-Ecosystem-blue.svg)](https://github.com/alphaparkinc/openclaw-genpark-bio-builder)
[![Zero Dependency](https://img.shields.io/badge/Dependencies-Standard_Library_Only-success.svg)](https://www.python.org/)
[![MCP Ready](https://img.shields.io/badge/MCP-Model_Context_Protocol-orange.svg)](https://modelcontextprotocol.io/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Production Grade](https://img.shields.io/badge/Status-Production_Ready-brightgreen.svg)](https://github.com/Alpha-Park/openclaw-genpark-bio-builder)

Production-grade agentic micro-skill designed for the OpenClaw and GenPark swarms. Built strictly using the Python standard library with zero external runtime dependencies.

## Architecture & Flow

```mermaid
flowchart TD
    A[Agent Planner / Host] -->|Tool Invocation| B(MCP Server Entrypoint)
    B --> C[OpenClawGenParkBioBuilder]
    C --> D[Deterministic Mathematical Algorithms]
    D --> E[Validated JSON Response]
    E -->|Structured Payload| A
```

## Features

- **Standard Library Only**: 100% Python standard library with no wheels, C-extensions, or pip requirements.
- **Model Context Protocol (MCP)**: Native FastMCP JSON-RPC interface for seamless tool-calling in Claude, Cursor, and OpenClaw.
- **Algorithmic Rigor**: Rigorous closed-form mathematical equations and quantitative deterministic metrics.
- **Multi-Tenant Mirrored**: Dual-deployed across `@alphaparkinc` and `@Alpha-Park`.

## Installation & Usage

```bash
git clone https://github.com/Alpha-Park/openclaw-genpark-bio-builder.git
cd openclaw-genpark-bio-builder
python example_usage.py
```

## MCP Configuration

Add to your `claude_desktop_config.json`:
```json
{
  "mcpServers": {
    "openclaw-genpark-bio-builder": {
      "command": "python",
      "args": ["-m", "openclaw-genpark-bio-builder.mcp_server"]
    }
  }
}
```

## License

MIT License. See [LICENSE](LICENSE) for details.
````

## File: .gitignore
size: 64
sha: ed8ae579cca3201f66148b37156e8f84a58a6680
upstream: https://github.com/alphaparkinc/openclaw-genpark-bio-builder/blob/HEAD/.gitignore

```text
__pycache__/\n*.py[cod]\n.env\n.venv/\nvenv/\n*.log\n.DS_Store\n
```

## File: client.py
size: 5502
sha: 8bb60950056fa9ebf842a32fdae8bae0795d8e18
upstream: https://github.com/alphaparkinc/openclaw-genpark-bio-builder/blob/HEAD/client.py

```text
# -*- coding: utf-8 -*-
"""
OpenClaw GenPark Bio Builder Client
Pure Python Standard Library (Zero External Dependencies)
Implements executive persona vector synthesis, career trajectory velocity scoring,
and cryptographic credential Merkle tree leaf hash generation.
"""

import math
import hashlib
from typing import Dict, Any, List, Optional

class OpenClawGenParkBioBuilder:
    """
    Algorithmic executive profiling and verifiable credential synthesis engine.
    """

    def __init__(self):
        self.seniority_weights = {
            "c_level": 5.0,
            "vp": 4.0,
            "director": 3.0,
            "lead": 2.0,
            "senior": 1.5,
            "staff": 2.5,
            "principal": 3.5
        }

    def synthesize_executive_persona_vector(
        self,
        experiences: List[Dict[str, Any]],
        skills: List[str],
        domain_authority_score: float = 85.0
    ) -> Dict[str, Any]:
        """
        Synthesizes executive persona profile metrics:
          - Seniority Depth Index
          - Domain Specialization Concentration (Herfindahl-Hirschman Index HHI on skill tags)
          - Executive Voice Tier
        """
        if not experiences:
            return {"persona_tier": "EMERGING", "seniority_depth_index": 0.0, "specialization_hhi": 0.0}

        total_weighted_months = 0.0
        total_months = 0.0

        for exp in experiences:
            months = float(exp.get("duration_months", 12))
            role_title = exp.get("title", "").lower()
            
            weight = 1.0
            for k, w in self.seniority_weights.items():
                if k in role_title:
                    weight = max(weight, w)
            
            total_weighted_months += months * weight
            total_months += months

        seniority_index = round((total_weighted_months / max(1.0, total_months)), 2)

        # Skill concentration HHI
        if skills:
            skill_freq = {}
            for s in skills:
                cat = s.split(":")[0].strip().lower() if ":" in s else "general"
                skill_freq[cat] = skill_freq.get(cat, 0) + 1
            tot = sum(skill_freq.values())
            shares = [count / tot for count in skill_freq.values()]
            hhi = round(sum(s**2 for s in shares), 4)
        else:
            hhi = 0.0

        # Voice Tier
        composite = (seniority_index * 15.0) + (domain_authority_score * 0.4) + (hhi * 20.0)
        if composite >= 75:
            tier = "VISIONARY_EXECUTIVE_L7"
        elif composite >= 55:
            tier = "SENIOR_LEADERSHIP_L6"
        else:
            tier = "PRACTITIONER_LEAD_L5"

        return {
            "executive_persona_tier": tier,
            "seniority_depth_index": seniority_index,
            "domain_specialization_hhi": hhi,
            "total_experience_months": int(total_months),
            "composite_influence_score": round(composite, 1)
        }

    def calculate_career_trajectory_velocity(
        self,
        career_milestones: List[Dict[str, Any]]
    ) -> Dict[str, Any]:
        """
        Calculates career promotion cadence velocity and career acceleration gradient:
          Velocity = sum( seniority_jump / max(0.5, years_in_role) ) / total_transitions
        """
        if len(career_milestones) < 2:
            return {
                "trajectory_status": "STABLE_BASE",
                "career_velocity_index": 1.0,
                "acceleration_gradient": 0.0
            }

        velocities = []
        for i in range(1, len(career_milestones)):
            prev = career_milestones[i - 1]
            curr = career_milestones[i]

            prev_level = float(prev.get("seniority_level", 1.0))
            curr_level = float(curr.get("seniority_level", 1.0))
            years = max(0.5, float(curr.get("tenure_years", 2.0)))

            jump = max(0.0, curr_level - prev_level)
            v = jump / years
            velocities.append(v)

        avg_velocity = round(sum(velocities) / len(velocities), 3)

        # Acceleration (derivative of velocity)
        gradient = round(velocities[-1] - velocities[0], 3) if len(velocities) >= 2 else 0.0

        if avg_velocity >= 1.0:
            status = "HYPER_GROWTH_FAST_TRACK"
        elif avg_velocity >= 0.5:
            status = "HEALTHY_ASCENDING_TRAJECTORY"
        else:
            status = "STEADY_TENURED_PACING"

        return {
            "trajectory_status": status,
            "career_velocity_index": avg_velocity,
            "acceleration_gradient": gradient,
            "total_milestone_transitions": len(velocities)
        }

    def generate_credential_merkle_leaf_hash(
        self,
        candidate_id: str,
        credential_type: str,
        issuing_authority: str,
        issue_timestamp_utc: int
    ) -> Dict[str, Any]:
        """
        Generates cryptographic double-SHA256 leaf hash for verifiable credentials on-chain:
          Leaf = SHA256( SHA256( candidate_id || type || authority || timestamp ) )
        """
        payload = f"{candidate_id}:{credential_type}:{issuing_authority}:{issue_timestamp_utc}".encode("utf-8")
        h1 = hashlib.sha256(payload).digest()
        h2 = hashlib.sha256(h1).hexdigest()

        return {
            "candidate_id": candidate_id,
            "credential_type": credential_type,
            "issuing_authority": issuing_authority,
            "issue_timestamp_utc": issue_timestamp_utc,
            "merkle_leaf_hash": f"0x{h2}"
        }
```

## File: example_usage.py
size: 1509
sha: cb416d218a70d4c4c6d44b9beb86289713e52df5
upstream: https://github.com/alphaparkinc/openclaw-genpark-bio-builder/blob/HEAD/example_usage.py

```text
# -*- coding: utf-8 -*-
from client import OpenClawGenParkBioBuilder

bio = OpenClawGenParkBioBuilder()

exps = [
    {"title": "Senior Software Engineer", "duration_months": 24},
    {"title": "Lead Infrastructure Architect", "duration_months": 36},
    {"title": "VP of Engineering", "duration_months": 30}
]
skills = ["ai:llm", "ai:agents", "infra:kubernetes", "infra:distributed", "mgmt:executive"]

# 1. Executive Persona Vector
persona = bio.synthesize_executive_persona_vector(exps, skills, domain_authority_score=90.0)
print(f"Persona Synthesis: Tier={persona['executive_persona_tier']} (Influence: {persona['composite_influence_score']})")
print(f"  Seniority Depth: {persona['seniority_depth_index']}, Specialization HHI: {persona['domain_specialization_hhi']}")

# 2. Career Trajectory Velocity
milestones = [
    {"role": "L3 Engineer", "seniority_level": 3.0, "tenure_years": 1.5},
    {"role": "L5 Senior", "seniority_level": 5.0, "tenure_years": 2.0},
    {"role": "L7 Director", "seniority_level": 7.0, "tenure_years": 2.5}
]
traj = bio.calculate_career_trajectory_velocity(milestones)
print()
print(f"Trajectory Velocity: Velocity={traj['career_velocity_index']} ({traj['trajectory_status']}, Accel={traj['acceleration_gradient']})")

# 3. Cryptographic Credential Leaf
leaf = bio.generate_credential_merkle_leaf_hash("usr_7701", "AI_ARCHITECT_CERTIFIED", "OPENCLAW_FOUNDATION", 1730000000)
print()
print(f"Verifiable Credential Leaf: {leaf['merkle_leaf_hash']} ({leaf['credential_type']})")
```

## File: LICENSE
size: 1071
sha: bafb53b2fc9253ffcac08bb8f6e8a474ddf0a5d2
upstream: https://github.com/alphaparkinc/openclaw-genpark-bio-builder/blob/HEAD/LICENSE

```text
MIT License

Copyright (c) 2026 AlphaPark Inc.

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
```

## File: mcp_server.py
size: 2037
sha: b5e305d31634faf6b893b62d8c05d30e17ddb9b1
upstream: https://github.com/alphaparkinc/openclaw-genpark-bio-builder/blob/HEAD/mcp_server.py

```text
# -*- coding: utf-8 -*-
"""
OpenClaw GenPark Bio Builder MCP Server
FastMCP standard interface for persona vector synthesis and career trajectory velocity scoring.
"""

import json
from typing import Dict, Any, List
from client import OpenClawGenParkBioBuilder

try:
    from mcp.server.fastmcp import FastMCP
    mcp = FastMCP("openclaw-genpark-bio-builder")
except ImportError:
    class MockFastMCP:
        def __init__(self, name):
            self.name = name
        def tool(self):
            def decorator(f):
                return f
            return decorator
    mcp = MockFastMCP("openclaw-genpark-bio-builder")

bio_builder = OpenClawGenParkBioBuilder()

@mcp.tool()
def synthesize_executive_persona_vector(
    experiences: List[Dict[str, Any]],
    skills: List[str],
    domain_authority_score: float = 85.0
) -> str:
    """
    Synthesizes executive persona profile metrics: Seniority Depth Index and Concentration HHI.
    """
    res = bio_builder.synthesize_executive_persona_vector(experiences, skills, domain_authority_score)
    return json.dumps(res, indent=2)

@mcp.tool()
def calculate_career_trajectory_velocity(
    career_milestones: List[Dict[str, Any]]
) -> str:
    """
    Calculates career promotion cadence velocity and career acceleration gradient.
    """
    res = bio_builder.calculate_career_trajectory_velocity(career_milestones)
    return json.dumps(res, indent=2)

@mcp.tool()
def generate_credential_merkle_leaf_hash(
    candidate_id: str,
    credential_type: str,
    issuing_authority: str,
    issue_timestamp_utc: int
) -> str:
    """
    Generates cryptographic double-SHA256 leaf hash for verifiable credentials.
    """
    res = bio_builder.generate_credential_merkle_leaf_hash(candidate_id, credential_type, issuing_authority, issue_timestamp_utc)
    return json.dumps(res, indent=2)

def main():
    print("Testing Bio Builder:")
    print(generate_credential_merkle_leaf_hash("usr_991", "EXECUTIVE_MBA", "STANFORD_GSB", 1729000000))

if __name__ == "__main__":
    main()
```

## File: requirements.txt
size: 76
sha: 0528add65f81b98e5d4083b7522a6a0ba35bc019
upstream: https://github.com/alphaparkinc/openclaw-genpark-bio-builder/blob/HEAD/requirements.txt

```text
# Zero external dependencies required -- Python 3.9+ standard library only\n
```

## File: skill.json
size: 413
sha: 2cf1fe5f6c8b263c04bbef6a42de9d9a8dc0bc82
upstream: https://github.com/alphaparkinc/openclaw-genpark-bio-builder/blob/HEAD/skill.json

```text
{
  "name": "openclaw-genpark-bio-builder",
  "version": "1.0.0",
  "description": "OpenClaw GenPark Bio Builder - Executive persona vector synthesis, career trajectory velocity scoring, and cryptographic credential Merkle leaf generation with zero dependencies.",
  "tools": [
    "synthesize_executive_persona_vector",
    "calculate_career_trajectory_velocity",
    "generate_credential_merkle_leaf_hash"
  ]
}
```