macos-resource-optimizer

macOS system resource optimization with 40 specialized agents for memory, disk, CPU, and process management

Zur Installation springen

Repository: rdmptv/AdbAutoPlayer
Letzte Quellaktivität: 3. Dezember 2025 um 16:22
Erkannte Sprache von SKILL.md: Englisch
Sterne: 0
Forks: 1

Installationsoptionen

Standardmäßig ist der Prompt ausgewählt, der zuerst die Quelle prüft. Sie können zu einem direkten Befehl wechseln oder eine lokale Kopie herunterladen.

Quelldateien prüfen

Lesen Sie SKILL.md und alle von SkillsMP angezeigten Begleitdateien, bevor Sie sich für eine Installation entscheiden.

Zurück zur Suche Zurück zur Installation

name	macos-resource-optimizer
description	macOS system resource optimization with 40 specialized agents for memory, disk, CPU, and process management
version	2.1.0
scripts_enabled	true
last_updated	"2025-11-30T00:00:00.000Z"
updated_in_phase	2.2
improvements	Performance metrics corrected, UV script architecture documented, protected apps expanded
auto_trigger_keywords	["macos","memory","optimizer","performance","ram","disk","cleanup","resource"]
scripts	[{"name":"coordinator","path":"scripts/coordinator.py","description":"Main orchestrator spawning 40 agents concurrently across 6 phases"}]
color	blue

macOS Resource Optimizer

Production-ready system optimization with 40+ specialized agents for comprehensive macOS resource management.

Quick Reference

What is macOS Resource Optimizer? Real-world macOS optimization framework with 40+ specialized agents executing in parallel:

coordinator.py: 40-agent orchestrator (6 phases, 4-5s execution)
40+ specialized agents: Memory, disk, browser, Docker, developer tools
Implementation: UV scripts (PEP 723) + Bash delegation via MoAI agents

Main Orchestrator:

Script	Purpose	Agents	Execution Time
`coordinator.py`	40-agent parallel orchestrator	40 agents (6 phases)	4-5s

6 Phases (coordinator.py):

Disk Cleanup (15 agents): Python/Node zombies, Browser helpers, Network leaks, Docker containers
RAM Optimization (9 agents): Memory pressure, App profiler, Browser tabs, Electron apps
Developer Cache (5 agents): Time Machine, Xcode, Build caches, Docker cleanup
Advanced Memory (4 agents): Swap optimizer, WindowServer, Spotlight, Memory leaks
Browser Deep Cleanup (3 agents): Chrome, Safari, Firefox optimizers
App & System (3 agents): Messaging apps, VSCode, DNS/Network

Performance:

Sequential: 40 × 1.0s = 40s (estimated per agent)
Parallel (6 phases): 4-5s total (8× faster than sequential)
Real-world: 4-7s depending on system state and cache availability
With MetricsCache (TTL 30s): ~2-3s on repeated calls

Usage

1. Full System Optimization (40 agents)

# Execute all 40 agents in 6 parallel phases
uv run scripts/coordinator.py

# JSON output
uv run scripts/coordinator.py --json

2. Individual Agents

# Memory pressure detector
uv run scripts/agent_memory_pressure_detector.py

# Browser tab manager
uv run scripts/agent_browser_tab_manager.py


uv run scripts/agent_docker_deep_cleanup.py --dry-run

# Kill zombie processes
uv run scripts/kill_zombies_parallel.py

# Report memory usage
uv run scripts/report_memory.py

# Analyze running processes
uv run scripts/analyze_processes.py --json

# Execute full 40-agent orchestration
result = Bash("uv run .claude/skills/macos-resource-optimizer/scripts/coordinator.py --json")
data = json.loads(result.stdout)

# Parse results by phase
phase1_results = data["phases"]["disk_cleanup"]
phase2_results = data["phases"]["ram_optimization"]

# Return aggregated recommendations

# Execute memory-specific agents
result = Bash("uv run scripts/agent_memory_pressure_detector.py --json")
memory_data = json.loads(result.stdout)

# Generate recommendations based on memory analysis

User Command (slash command)
    ↓
MoAI Command (Python orchestrator)
    ↓
Task() delegation to manager agents
    ↓
Manager-Resource-Coordinator (MoAI agent)
    ↓
Bash(uv run coordinator.py) → UV Script execution
    ↓
asyncio.gather() parallel execution
    ├─ Phase 1: Disk Cleanup (15 agents)
    ├─ Phase 2: RAM Optimization (9 agents)
    ├─ Phase 3: Developer Cache (5 agents)
    ├─ Phase 4: Advanced Memory (4 agents)
    ├─ Phase 5: Browser Cleanup (3 agents)
    └─ Phase 6: App & System (3 agents)
    ↓
JSON results aggregation
    ↓
User-facing report (Korean)

#!/usr/bin/env uv run
# /// script
# requires-python = ">=3.11"
# dependencies = ["psutil", "pyyaml"]
# ///

import asyncio
import psutil

# Scripts run directly via: uv run script.py
# No Python virtual environment setup required

# Manager agent receives command
# Delegates to Bash tool: uv run .claude/skills/.../scripts/coordinator.py
# Coordinator spawns async tasks for 40 agents
# Results aggregated and returned

# coordinator.py executes agents
{
    "phases": {
        "disk_cleanup": {
            "agents_executed": 15,
            "duration": 2.1,
            "savings_gb": 5.3,
            "results": [...]
        },
        "ram_optimization": {
            "agents_executed": 9,
            "duration": 1.8,
            "memory_freed_gb": 2.1,
            "results": [...]
        },
        ...
    },
    "summary": {
        "total_agents": 40,
        "total_duration": 2.5,
        "total_savings_gb": 12.4,
        "total_memory_freed_gb": 4.2
    }
}

Metric	Value
Total Agents	40+ specialized agents
Orchestrators	1 (coordinator only)
Execution Time (parallel)	4-5s (first run), 2-3s (cached)
Execution Time (sequential)	~40s (estimated)
Speed Improvement	8× faster (parallel vs sequential)
Memory Saved (typical)	1-3 GB
Disk Saved (typical)	0.4-2.5 GB
Actual Results (2025-11-30)	+413MB disk, 18% of goal

Execute full system analysis via coordinator.py.

## Workflow

1. Delegate to manager-resource-coordinator
2. Coordinator executes: `uv run scripts/coordinator.py --json`
3. Parse JSON results
4. Return formatted analysis with recommendations

Execute system optimization via coordinator.py.

## Workflow

1. Delegate to manager-resource-coordinator
2. Coordinator executes: `uv run scripts/coordinator.py --json`
3. Parse and validate results
4. Apply optimizations if approved
5. Return optimization results