openclaw-genpark-music-creator

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

• SKILL.md1.8 KB766aadda14e5upstream ↗

  ---
  name: openclaw-genpark-music-creator
  description: OpenClaw GenPark Music Creator - Harmonic overtone series synthesizer, MIDI note frequency & equal temperament scaler, and Markov chain chord progression composer with zero dependencies.
  category: Service
  version: 1.0.0
  license: MIT
  tools:
    - synthesize_harmonic_overtones
    - convert_midi_and_pitch_scale
    - generate_markov_chord_progression
  ---
  
  # Openclaw Genpark Music Creator
  
  ## Overview & Agent Behavioral Directives
  You are an autonomous agent specialized in **Openclaw Genpark Music Creator**.
  Your primary directive is to execute: OpenClaw GenPark Music Creator - Harmonic overtone series synthesizer, MIDI note frequency & equal temperament scaler, and Markov chain chord progression composer with zero dependencies.
  Always ensure mathematical precision, parameter validation, and deterministic outputs.
  
  ## When to Activate This Skill
  - Activate when an agent workflow or user instruction requires:
  - `synthesize_harmonic_overtones`
  - `convert_midi_and_pitch_scale`
  - `generate_markov_chord_progression`
  - Activate when operating in zero-dependency environments requiring pure Python standard library execution.
  
  ## How to Execute
  
  ### Option 1: Direct Python Execution (Zero-Dependency)
  ```python
  from client import *
  
  # Client operates purely on standard Python library:
  # Initialized and ready for direct function invocation.
  ```
  
  ### Option 2: FastMCP Tool Calling
  Tools registered in `mcp_server.py`:
  - `synthesize_harmonic_overtones`
  - `convert_midi_and_pitch_scale`
  - `generate_markov_chord_progression`
  
  ## Core Mathematical & Algorithmic Guardrails
  - **Zero-Dependency Policy**: 100% Python standard library only (`math`, `heapq`, `hashlib`, `urllib`, `collections`, `itertools`, `typing`).
  - **Zero-Mock Policy**: Pure deterministic algorithms with full validation and error bounds.
  

• README.md56 B9fa4905cd520upstream ↗

  # genpark-music-creator
  
  Auto-distilled OpenClaw skill.
  

• .gitignore90 Bfa896226f33cupstream ↗

  __pycache__/
  *.py[cod]
  *$py.class
  .pytest_cache/
  .env
  venv/
  env/
  dist/
  build/
  *.egg-info/
  

• client.py7.9 KBedc6b91800a7upstream ↗

  # -*- coding: utf-8 -*-
  """
  OpenClaw GenPark Music Creator Client
  Zero-dependency musical signal synthesizer, MIDI pitch converter, and Markov chord progression composer.
  """
  
  import math
  import random
  from typing import Dict, List, Any, Optional
  
  class OpenClawGenParkMusicCreator:
      """
      Synthesizes harmonic overtones, converts MIDI pitches with microtonal cents precision,
      and composes diatonic chord progressions using Markov transition matrices.
      """
  
      NOTE_NAMES = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"]
  
      DIATONIC_CHORDS_MAJOR = {
          "I": ["C", "E", "G"],
          "ii": ["D", "F", "A"],
          "iii": ["E", "G", "B"],
          "IV": ["F", "A", "C"],
          "V": ["G", "B", "D"],
          "vi": ["A", "C", "E"],
          "vii*": ["B", "D", "F"]
      }
  
      # Transition probability matrix for functional diatonic harmony (Major)
      TRANSITIONS_MAJOR = {
          "I": {"I": 0.05, "ii": 0.15, "iii": 0.05, "IV": 0.30, "V": 0.30, "vi": 0.15},
          "ii": {"V": 0.65, "vii*": 0.15, "IV": 0.10, "I": 0.10},
          "iii": {"vi": 0.60, "IV": 0.25, "ii": 0.15},
          "IV": {"V": 0.45, "I": 0.25, "ii": 0.20, "vii*": 0.10},
          "V": {"I": 0.70, "vi": 0.20, "IV": 0.10},
          "vi": {"ii": 0.35, "IV": 0.35, "V": 0.20, "iii": 0.10},
          "vii*": {"I": 0.85, "iii": 0.15}
      }
  
      def synthesize_harmonic_overtones(
          self,
          fundamental_freq_hz: float,
          duration_ms: float = 1000.0,
          sample_rate_hz: int = 44100,
          harmonic_weights: Optional[List[float]] = None
      ) -> Dict[str, Any]:
          """
          Synthesizes harmonic overtone spectrum f_k = (k+1)*f_0 and computes RMS, peak, and spectral centroid.
          """
          if fundamental_freq_hz <= 0:
              raise ValueError("Fundamental frequency must be strictly positive.")
          if duration_ms <= 0:
              raise ValueError("Duration must be strictly positive.")
  
          weights = harmonic_weights or [1.0, 0.5, 0.25, 0.125, 0.0625]
          total_weight = sum(weights)
          norm_weights = [w / total_weight for w in weights]
  
          # Analyze overtones
          overtones = []
          for idx, w in enumerate(norm_weights):
              k = idx + 1
              freq = round(fundamental_freq_hz * k, 2)
              overtones.append({
                  "harmonic_index": k,
                  "frequency_hz": freq,
                  "relative_weight": round(w, 4),
                  "is_audible": freq < 20000.0
              })
  
          # Generate sample points (simulate discrete synthesis window of 256 samples)
          num_samples = min(256, int(sample_rate_hz * (duration_ms / 1000.0)))
          waveform_samples = []
          sum_sq = 0.0
          peak_amp = 0.0
  
          for n in range(num_samples):
              t = n / sample_rate_hz
              val = 0.0
              for idx, w in enumerate(norm_weights):
                  k = idx + 1
                  freq = fundamental_freq_hz * k
                  val += w * math.sin(2.0 * math.pi * freq * t)
              
              abs_v = abs(val)
              if abs_v > peak_amp:
                  peak_amp = abs_v
              sum_sq += val * val
              if n < 32:  # store sample slice
                  waveform_samples.append(round(val, 4))
  
          rms_power = round(math.sqrt(sum_sq / max(1, num_samples)), 4)
          crest_factor = round(peak_amp / (rms_power + 1e-9), 3)
  
          # Spectral Centroid (f_centroid = sum(f_k * w_k) / sum(w_k))
          spectral_centroid_hz = round(sum( fundamental_freq_hz * (i + 1) * w for i, w in enumerate(norm_weights) ), 2)
  
          return {
              "fundamental_freq_hz": fundamental_freq_hz,
              "duration_ms": duration_ms,
              "sample_rate_hz": sample_rate_hz,
              "harmonic_count": len(overtones),
              "spectral_centroid_hz": spectral_centroid_hz,
              "rms_amplitude": rms_power,
              "peak_amplitude": round(peak_amp, 4),
              "crest_factor": crest_factor,
              "overtone_spectrum": overtones,
              "waveform_preview_32_samples": waveform_samples
          }
  
      def convert_midi_and_pitch_scale(
          self,
          midi_note_or_freq: float,
          is_midi_number: bool = True,
          a4_tuning_hz: float = 440.0
      ) -> Dict[str, Any]:
          """
          Converts between MIDI note number and acoustic frequency with microtonal cents precision.
          Formula: f = A4 * 2^((m - 69) / 12)
          """
          if is_midi_number:
              midi_num = midi_note_or_freq
              freq_hz = a4_tuning_hz * math.pow(2.0, (midi_num - 69.0) / 12.0)
          else:
              if midi_note_or_freq <= 0:
                  raise ValueError("Frequency must be strictly positive.")
              freq_hz = midi_note_or_freq
              midi_num = 69.0 + 12.0 * math.log2(freq_hz / a4_tuning_hz)
  
          closest_midi = int(round(midi_num))
          cents_deviation = round(100.0 * (midi_num - closest_midi), 2)
          
          note_idx = closest_midi % 12
          octave = (closest_midi // 12) - 1
          note_name = f"{self.NOTE_NAMES[note_idx]}{octave}"
  
          # Standard 88-key piano key index (A0 = key 1, C8 = key 88)
          piano_key = closest_midi - 20
          is_standard_piano = 1 <= piano_key <= 88
  
          return {
              "input_val": midi_note_or_freq,
              "is_midi_input": is_midi_number,
              "frequency_hz": round(freq_hz, 3),
              "midi_note_number": round(midi_num, 3),
              "closest_note_name": note_name,
              "cents_deviation": cents_deviation,
              "piano_key_index": piano_key if is_standard_piano else None,
              "is_standard_piano_range": is_standard_piano,
              "a4_reference_hz": a4_tuning_hz
          }
  
      def generate_markov_chord_progression(
          self,
          seed_chord: str = "I",
          scale_mode: str = "major",
          length: int = 8,
          harmonic_rhythm: str = "4/4"
      ) -> Dict[str, Any]:
          """
          Generates a chord progression using functional diatonic Markov transition probabilities.
          """
          if length <= 0:
              raise ValueError("Progression length must be at least 1.")
  
          current = seed_chord if seed_chord in self.TRANSITIONS_MAJOR else "I"
          progression = []
          transitions = self.TRANSITIONS_MAJOR
  
          # Deterministic pseudo-random seed sequence based on input
          rng = random.Random(hash(f"{seed_chord}_{scale_mode}_{length}"))
  
          for step in range(length):
              chord_notes = self.DIATONIC_CHORDS_MAJOR.get(current, ["C", "E", "G"])
              progression.append({
                  "bar": step + 1,
                  "roman_numeral": current,
                  "chord_symbol": f"{chord_notes[0]}maj" if current in ["I", "IV", "V"] else (f"{chord_notes[0]}dim" if current == "vii*" else f"{chord_notes[0]}min"),
                  "notes": chord_notes,
                  "harmonic_function": "Tonic" if current in ["I", "vi", "iii"] else ("Subdominant" if current in ["IV", "ii"] else "Dominant")
              })
  
              # Transition to next chord
              probs = transitions.get(current, {"I": 1.0})
              r = rng.random()
              cum = 0.0
              next_chord = "I"
              for cand, p in probs.items():
                  cum += p
                  if r <= cum:
                      next_chord = cand
                      break
              current = next_chord
  
          # Calculate harmonic tension curve (Dominant has highest tension 1.0, Subdominant 0.6, Tonic 0.2)
          tension_map = {"Tonic": 0.2, "Subdominant": 0.6, "Dominant": 1.0}
          tension_curve = [tension_map.get(c["harmonic_function"], 0.2) for c in progression]
          avg_tension = round(sum(tension_curve) / len(tension_curve), 3)
  
          return {
              "seed_chord": seed_chord,
              "scale_mode": scale_mode,
              "length_bars": length,
              "harmonic_rhythm": harmonic_rhythm,
              "average_tension": avg_tension,
              "cadence_concluded": progression[-1]["roman_numeral"] in ["I", "V"],
              "chords": progression
          }
  

• example_usage.py1.2 KB52aede31ef1fupstream ↗

  # -*- coding: utf-8 -*-
  from client import OpenClawGenParkMusicCreator
  
  creator = OpenClawGenParkMusicCreator()
  
  # 1. Harmonic Overtones Synthesis
  overtones = creator.synthesize_harmonic_overtones(fundamental_freq_hz=440.0, duration_ms=500.0)
  print(f"Overtone Synthesis: Fundamental={overtones['fundamental_freq_hz']}Hz, Centroid={overtones['spectral_centroid_hz']}Hz, RMS={overtones['rms_amplitude']}")
  
  # 2. MIDI & Pitch Scale Conversion
  pitch = creator.convert_midi_and_pitch_scale(midi_note_or_freq=60.0, is_midi_number=True)
  print()
  print(f"MIDI 60 Conversion: Note={pitch['closest_note_name']}, Freq={pitch['frequency_hz']}Hz, PianoKey={pitch['piano_key_index']}")
  
  freq_pitch = creator.convert_midi_and_pitch_scale(midi_note_or_freq=523.25, is_midi_number=False)
  print(f"Freq 523.25Hz Conversion: ClosestNote={freq_pitch['closest_note_name']}, CentsDeviation={freq_pitch['cents_deviation']}")
  
  # 3. Markov Chord Progression
  prog = creator.generate_markov_chord_progression(seed_chord="I", length=6)
  print()
  print(f"Markov Chord Progression (Avg Tension: {prog['average_tension']}):")
  for bar in prog["chords"]:
      print(f"  Bar {bar['bar']}: {bar['roman_numeral']} ({bar['chord_symbol']}) - {bar['harmonic_function']} [{', '.join(bar['notes'])}]")
  

• 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.py1.7 KBe5d242402733upstream ↗

  # -*- coding: utf-8 -*-
  """
  OpenClaw GenPark Music Creator FastMCP Server
  """
  
  import json
  from typing import List, Optional
  from mcp.server.fastmcp import FastMCP
  from client import OpenClawGenParkMusicCreator
  
  mcp = FastMCP("openclaw-genpark-music-creator")
  creator = OpenClawGenParkMusicCreator()
  
  @mcp.tool()
  def synthesize_harmonic_overtones(
      fundamental_freq_hz: float,
      duration_ms: float = 1000.0,
      sample_rate_hz: int = 44100,
      harmonic_weights: Optional[List[float]] = None
  ) -> str:
      """
      Synthesizes harmonic overtone spectrum f_k = (k+1)*f_0 and computes RMS power and spectral centroid.
      """
      res = creator.synthesize_harmonic_overtones(fundamental_freq_hz, duration_ms, sample_rate_hz, harmonic_weights)
      return json.dumps(res, indent=2)
  
  @mcp.tool()
  def convert_midi_and_pitch_scale(
      midi_note_or_freq: float,
      is_midi_number: bool = True,
      a4_tuning_hz: float = 440.0
  ) -> str:
      """
      Converts between MIDI note number and acoustic frequency with microtonal cents precision.
      """
      res = creator.convert_midi_and_pitch_scale(midi_note_or_freq, is_midi_number, a4_tuning_hz)
      return json.dumps(res, indent=2)
  
  @mcp.tool()
  def generate_markov_chord_progression(
      seed_chord: str = "I",
      scale_mode: str = "major",
      length: int = 8,
      harmonic_rhythm: str = "4/4"
  ) -> str:
      """
      Generates a chord progression using functional diatonic Markov transition probabilities.
      """
      res = creator.generate_markov_chord_progression(seed_chord, scale_mode, length, harmonic_rhythm)
      return json.dumps(res, indent=2)
  
  def main():
      print("Testing Music Creator:")
      print(generate_markov_chord_progression("I", "major", 4))
  
  if __name__ == "__main__":
      main()
  

• requirements.txt11 Bc413b608a2caupstream ↗

  mcp>=1.0.0
  

• skill.json406 B0649097840d7upstream ↗

  {
    "name": "openclaw-genpark-music-creator",
    "version": "1.0.0",
    "description": "OpenClaw GenPark Music Creator - Harmonic overtone series synthesizer, MIDI note frequency & equal temperament scaler, and Markov chain chord progression composer with zero dependencies.",
    "tools": [
      "synthesize_harmonic_overtones",
      "convert_midi_and_pitch_scale",
      "generate_markov_chord_progression"
    ]
  }

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