genpark-bio-builder

9 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

• SKILL.md1.3 KB05c0e28e9658upstream ↗

  ---
  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.
  

• README.md2.0 KB77666464f9a7upstream ↗

  # 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.
  

• .gitignore64 Bed8ae579cca3upstream ↗

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

• client.py5.4 KB8bb60950056fupstream ↗

  # -*- 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}"
          }
  

• example_usage.py1.5 KBcb416d218a70upstream ↗

  # -*- 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']})")
  

• LICENSE1.0 KBbafb53b2fc92upstream ↗

  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.
  

• mcp_server.py2.0 KBb5e305d31634upstream ↗

  # -*- 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()
  

• requirements.txt76 B0528add65f81upstream ↗

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

• skill.json413 B2cf1fe5f6c8bupstream ↗

  {
    "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"
    ]
  }

Plain-text copy, no login: /skill-bundles/alphaparkinc-openclaw-genpark-bio-builder.md