cli_hr_example.py - ResonanceOS v6 Documentation

CLI Integration Thesis

The cli_hr_example.py module demonstrates the fundamental Command Line Interface (CLI) integration capabilities of ResonanceOS v6, providing a simple yet powerful example of how to interact with the Human-Resonant generation system through subprocess execution. This concise example showcases the core CLI communication pattern, including subprocess invocation, parameter passing, tenant specification, and profile selection - all designed to provide developers with a straightforward starting point for integrating ResonanceOS capabilities into their command-line workflows and automation scripts.

Technical Specifications

Interface: Python subprocess module for CLI execution
Script: resonance_os/cli/hr_main.py for CLI operations
Parameters: Prompt, tenant, and profile configuration
Execution: Synchronous subprocess.run() method
Integration: Easy embedding in automation scripts

Core CLI Integration

import subprocess

# Execute ResonanceOS CLI with parameters
subprocess.run([
    "python", "resonance_os/cli/hr_main.py",
    "--prompt", "Write a compelling AI article about resonance tone",
    "--tenant", "default",
    "--profile", "brand_identity_v1"
])
                

Simple Integration

Minimal code for CLI integration

Parameter Control

Command-line argument configuration

Multi-Tenant Support

Tenant-specific content generation

Profile Selection

HRV profile-based styling

CLI Integration Workflow

1. Prepare Command

Construct CLI command with parameters

↓

2. Execute Subprocess

Run CLI script via subprocess

↓

3. Generate Content

Process prompt with specified profile

↓

4. Return Results

Output generated content to console

Command Structure & Components

CLI Command Architecture

# Command structure breakdown
command_components = [
    "python",                              # Interpreter
    "resonance_os/cli/hr_main.py",        # CLI script path
    "--prompt", "Your content prompt here",  # Content request
    "--tenant", "organization_name",        # Multi-tenant ID
    "--profile", "hrv_profile_name"          # Style profile
]

# Execution with subprocess
result = subprocess.run(command_components, capture_output=True, text=True)

# Output handling
if result.returncode == 0:
    print("✅ Content generated successfully")
    print(result.stdout)
else:
    print("❌ Generation failed")
    print(result.stderr)
                    

Command Components

Python Interpreter

Script execution environment

CLI Script Path

Main CLI interface script

Prompt Parameter

Content generation request

Tenant Parameter

Multi-tenant organization ID

Profile Parameter

HRV profile for styling

Subprocess Module

Process execution management

Parameter Configuration Options

CLI Parameter Management

def generate_with_cli(prompt, tenant="default", profile="neutral", 
                          output_file=None, verbose=False):
    """Generate content using CLI with advanced options"""
    
    # Build command with parameters
    command = [
        "python",
        "resonance_os/cli/hr_main.py",
        "--prompt", prompt,
        "--tenant", tenant,
        "--profile", profile
    ]
    
    # Add optional parameters
    if output_file:
        command.extend(["--output", output_file])
    
    if verbose:
        command.append("--verbose")
    
    # Execute command
    try:
        result = subprocess.run(
            command,
            capture_output=True,
            text=True,
            timeout=60
        )
        
        if result.returncode == 0:
            print(f"✅ Generated content for tenant '{tenant}' with profile '{profile}'")
            return result.stdout
        else:
            print(f"❌ CLI error: {result.stderr}")
            return None
            
    except subprocess.TimeoutExpired:
        print("❌ CLI execution timed out")
        return None
    except Exception as e:
        print(f"❌ CLI execution error: {e}")
        return None

# Usage examples
# Basic usage
content = generate_with_cli("AI technology trends")

# Advanced usage
content = generate_with_cli(
    prompt="Future of artificial intelligence",
    tenant="tech_company",
    profile="professional_modern",
    output_file="ai_article.txt",
    verbose=True
)
                    

Parameter Features

Prompt Control

Content generation request

Tenant Specification

Multi-tenant organization

Profile Selection

HRV style configuration

Output Options

File output configuration

Verbose Mode

Detailed execution logging

Timeout Control

Execution time limits

Process Management & Control

Subprocess Execution Management

import subprocess
import threading
import time

class CLIManager:
    """Advanced CLI process management"""
    
    def __init__(self, timeout=60):
        self.timeout = timeout
        self.active_processes = {}
    
    def execute_async(self, prompt, tenant="default", profile="neutral"):
        """Execute CLI command asynchronously"""
        
        command = [
            "python",
            "resonance_os/cli/hr_main.py",
            "--prompt", prompt,
            "--tenant", tenant,
            "--profile", profile
        ]
        
        # Start subprocess
        process = subprocess.Popen(
            command,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            text=True
        )
        
        # Track process
        process_id = id(process)
        self.active_processes[process_id] = process
        
        # Start timeout monitoring
        timer = threading.Timer(self.timeout, self._timeout_handler, [process_id])
        timer.start()
        
        return process_id, process
    
    def _timeout_handler(self, process_id):
        """Handle process timeout"""
        
        if process_id in self.active_processes:
            process = self.active_processes[process_id]
            process.terminate()
            print(f"⏰ Process {process_id} timed out and was terminated")
    
    def get_result(self, process_id):
        """Get execution result for async process"""
        
        if process_id in self.active_processes:
            process = self.active_processes[process_id]
            
            try:
                stdout, stderr = process.communicate(timeout=1)
                
                if process.returncode == 0:
                    return {"success": True, "output": stdout}
                else:
                    return {"success": False, "error": stderr}
                    
            finally:
                # Clean up
                del self.active_processes[process_id]
        
        return {"success": False, "error": "Process not found"}

# Usage example
manager = CLIManager(timeout=30)

# Start async execution
process_id, process = manager.execute_async(
    "AI and human collaboration",
    tenant="research_org",
    profile="academic_formal"
)

# Wait for completion
time.sleep(5)

# Get result
result = manager.get_result(process_id)
if result["success"]:
    print("✅ Content generated successfully")
    print(result["output"])
else:
    print(f"❌ Generation failed: {result['error']}")
                    

Process Management Features

Async Execution

Yes

Non-blocking process execution

Timeout Control

60s

Automatic process termination

Process Tracking

Active

Monitor multiple processes

Result Handling

Structured

Organized output processing

Integration Benefits & Use Cases

CLI Integration Advantages

# Integration use cases
integration_scenarios = {
    "automation_scripts": {
        "description": "Automated content generation workflows",
        "benefits": ["Scheduled generation", "Batch processing", "Pipeline integration"]
    },
    "development_tools": {
        "description": "IDE and editor integrations",
        "benefits": ["Real-time assistance", "Code generation", "Documentation help"]
    },
    "ci_cd_pipelines": {
        "description": "Continuous integration workflows",
        "benefits": ["Auto documentation", "Release notes", "Content validation"]
    },
    "batch_operations": {
        "description": "Large-scale content processing",
        "benefits": ["Bulk generation", "Parallel processing", "Quality control"]
    }
}

# Example: Automated content pipeline
def content_pipeline(topics, tenant, profile):
    """Automated content generation pipeline"""
    
    results = []
    
    for topic in topics:
        print(f"⚙️ Processing topic: {topic}")
        
        # Generate content via CLI
        result = subprocess.run([
            "python", "resonance_os/cli/hr_main.py",
            "--prompt", topic,
            "--tenant", tenant,
            "--profile", profile,
            "--output", f"output/{topic.replace(' ', '_')}.txt"
        ], capture_output=True, text=True)
        
        if result.returncode == 0:
            results.append({"topic": topic, "status": "success"})
            print(f"✅ Generated: {topic}")
        else:
            results.append({"topic": topic, "status": "failed", "error": result.stderr})
            print(f"❌ Failed: {topic}")
    
    return results

# Execute pipeline
topics = [
    "AI in healthcare",
    "Machine learning trends",
    "Data science applications",
    "Neural network advances"
]

pipeline_results = content_pipeline(topics, "tech_blog", "tech_enthusiastic")
print(f"📈 Pipeline completed: {len([r for r in pipeline_results if r['status'] == 'success'])}/{len(topics)} successful")
                    

Integration Benefits

Automation Ready

Perfect for scripted workflows

Multi-Tenant

Support for multiple organizations

Profile Control

Consistent styling across batches

Pipeline Integration

CI/CD workflow compatibility

Batch Processing

Large-scale content generation

Process Management

Advanced execution control

Technical Implementation Thesis

The cli_hr_example.py module represents the fundamental CLI integration capabilities of ResonanceOS v6, demonstrating how developers can easily integrate human-resonant content generation into their command-line workflows and automation scripts. This implementation showcases sophisticated understanding of subprocess management, parameter configuration, process control, and production-ready patterns while providing a simple yet powerful starting point for building comprehensive integrations that leverage the full capabilities of the ResonanceOS system through familiar command-line interfaces.

CLI Integration Philosophy

Simplicity First: Minimal code for maximum functionality
Standard Interface: Familiar CLI patterns for developers
Process Control: Comprehensive subprocess management
Automation Ready: Perfect for scripted workflows

Key Integration Features

Simple CLI Calls

Minimal code for content generation.

Parameter Control

Flexible command-line configuration.

Process Management

Advanced subprocess execution control.

Automation Ready

Perfect for scripted workflows.