loudmouth-ai 0.1.0 → 0.2.0

package/extensions/open-prose/skills/prose/examples/23-retry-with-backoff.prose

@@ -1,63 +0,0 @@
-# Retry with Backoff Example
-# Demonstrates automatic retry patterns for resilient API calls
-
-# Simple retry - try up to 3 times on failure
-session "Call flaky third-party API"
-  retry: 3
-
-# Retry with exponential backoff for rate-limited APIs
-session "Query rate-limited service"
-  retry: 5
-  backoff: "exponential"
-
-# Retry with linear backoff
-session "Send webhook notification"
-  retry: 3
-  backoff: "linear"
-
-# Combining retry with context passing
-let config = session "Load API configuration"
-
-session "Make authenticated API request"
-  context: config
-  retry: 3
-  backoff: "exponential"
-
-# Retry inside try/catch for fallback after all retries fail
-try:
-  session "Call primary payment processor"
-    retry: 3
-    backoff: "exponential"
-catch:
-  session "All retries failed - use backup payment processor"
-    retry: 2
-
-# Parallel retries for redundant services
-parallel:
-  primary = try:
-    session "Query primary database"
-      retry: 2
-      backoff: "linear"
-  catch:
-    session "Primary DB unavailable"
-  replica = try:
-    session "Query replica database"
-      retry: 2
-      backoff: "linear"
-  catch:
-    session "Replica DB unavailable"
-
-session "Merge results from available databases"
-  context: { primary, replica }
-
-# Retry in a loop for batch processing
-let items = ["batch1", "batch2", "batch3"]
-for item in items:
-  try:
-    session "Process this batch item"
-      context: item
-      retry: 2
-      backoff: "exponential"
-  catch:
-    session "Log failed batch for manual review"
-      context: item

package/extensions/open-prose/skills/prose/examples/24-choice-blocks.prose

@@ -1,86 +0,0 @@
-# Choice Blocks Example
-# Demonstrates AI-selected branching based on runtime criteria
-
-# Simple choice based on analysis
-let analysis = session "Analyze the current codebase quality"
-
-choice **the severity of issues found**:
-  option "Critical":
-    session "Stop all work and fix critical issues immediately"
-      context: analysis
-    session "Create incident report"
-  option "Moderate":
-    session "Schedule fixes for next sprint"
-      context: analysis
-  option "Minor":
-    session "Add to technical debt backlog"
-      context: analysis
-
-# Choice for user experience level
-choice **the user's technical expertise based on their question**:
-  option "Beginner":
-    session "Explain concepts from first principles"
-    session "Provide step-by-step tutorial"
-    session "Include helpful analogies"
-  option "Intermediate":
-    session "Give concise explanation with examples"
-    session "Link to relevant documentation"
-  option "Expert":
-    session "Provide technical deep-dive"
-    session "Include advanced configuration options"
-
-# Choice for project approach
-let requirements = session "Gather project requirements"
-
-choice **the best development approach given the requirements**:
-  option "Rapid prototype":
-    session "Create quick MVP focusing on core features"
-      context: requirements
-    session "Plan iteration cycle"
-  option "Production-ready":
-    session "Design complete architecture"
-      context: requirements
-    session "Set up CI/CD pipeline"
-    session "Implement with full test coverage"
-  option "Research spike":
-    session "Explore technical feasibility"
-      context: requirements
-    session "Document findings and recommendations"
-
-# Multi-line criteria for complex decisions
-let market_data = session "Gather market research data"
-let tech_analysis = session "Analyze technical landscape"
-
-choice ***
-  the optimal market entry strategy
-  considering both market conditions
-  and technical readiness
-***:
-  option "Aggressive launch":
-    session "Prepare for immediate market entry"
-      context: [market_data, tech_analysis]
-  option "Soft launch":
-    session "Plan limited beta release"
-      context: [market_data, tech_analysis]
-  option "Wait and iterate":
-    session "Continue development and monitor market"
-      context: [market_data, tech_analysis]
-
-# Nested choices for detailed decision trees
-let request = session "Analyze incoming customer request"
-
-choice **the type of request**:
-  option "Technical support":
-    choice **the complexity of the technical issue**:
-      option "Simple":
-        session "Provide self-service solution"
-          context: request
-      option "Complex":
-        session "Escalate to senior engineer"
-          context: request
-  option "Sales inquiry":
-    session "Forward to sales team with context"
-      context: request
-  option "Feature request":
-    session "Add to product backlog and notify PM"
-      context: request

package/extensions/open-prose/skills/prose/examples/25-conditionals.prose

@@ -1,114 +0,0 @@
-# Conditionals Example
-# Demonstrates if/elif/else patterns with AI-evaluated conditions
-
-# Simple if statement
-let health_check = session "Check system health status"
-
-if **the system is unhealthy**:
-  session "Alert on-call engineer"
-    context: health_check
-  session "Begin incident response"
-
-# If/else for binary decisions
-let review = session "Review the pull request changes"
-
-if **the code changes are safe and well-tested**:
-  session "Approve and merge the pull request"
-    context: review
-else:
-  session "Request changes with detailed feedback"
-    context: review
-
-# If/elif/else for multiple conditions
-let status = session "Check project milestone status"
-
-if **the project is ahead of schedule**:
-  session "Document success factors"
-  session "Consider adding stretch goals"
-elif **the project is on track**:
-  session "Continue with current plan"
-  session "Prepare status report"
-elif **the project is slightly delayed**:
-  session "Identify bottlenecks"
-  session "Adjust timeline and communicate to stakeholders"
-else:
-  session "Escalate to management"
-  session "Create recovery plan"
-  session "Schedule daily standups"
-
-# Multi-line conditions
-let test_results = session "Run full test suite"
-
-if ***
-  all tests pass
-  and code coverage is above 80%
-  and there are no linting errors
-***:
-  session "Deploy to production"
-else:
-  session "Fix issues before deploying"
-    context: test_results
-
-# Nested conditionals
-let request = session "Analyze the API request"
-
-if **the request is authenticated**:
-  if **the user has admin privileges**:
-    session "Process admin request with full access"
-      context: request
-  else:
-    session "Process standard user request"
-      context: request
-else:
-  session "Return 401 authentication error"
-
-# Conditionals with error handling
-let operation_result = session "Attempt complex operation"
-
-if **the operation succeeded partially**:
-  session "Complete remaining steps"
-    context: operation_result
-
-try:
-  session "Perform another risky operation"
-catch as err:
-  if **the error is recoverable**:
-    session "Apply automatic recovery procedure"
-      context: err
-  else:
-    throw "Unrecoverable error encountered"
-
-# Conditionals inside loops
-let items = ["item1", "item2", "item3"]
-
-for item in items:
-  session "Analyze this item"
-    context: item
-
-  if **the item needs processing**:
-    session "Process the item"
-      context: item
-  elif **the item should be skipped**:
-    session "Log skip reason"
-      context: item
-  else:
-    session "Archive the item"
-      context: item
-
-# Conditionals with parallel blocks
-parallel:
-  security = session "Run security scan"
-  performance = session "Run performance tests"
-  style = session "Run style checks"
-
-if **security issues were found**:
-  session "Fix security issues immediately"
-    context: security
-elif **performance issues were found**:
-  session "Optimize performance bottlenecks"
-    context: performance
-elif **style issues were found**:
-  session "Clean up code style"
-    context: style
-else:
-  session "All checks passed - ready for review"

package/extensions/open-prose/skills/prose/examples/26-parameterized-blocks.prose

@@ -1,100 +0,0 @@
-# Parameterized Blocks Example
-# Demonstrates reusable blocks with arguments for DRY workflows
-
-# Simple parameterized block
-block research(topic):
-  session "Research {topic} thoroughly"
-  session "Summarize key findings about {topic}"
-  session "List open questions about {topic}"
-
-# Invoke with different arguments
-do research("quantum computing")
-do research("machine learning")
-do research("blockchain technology")
-
-# Block with multiple parameters
-block review_code(language, focus_area):
-  session "Review the {language} code for {focus_area} issues"
-  session "Suggest {focus_area} improvements for {language}"
-  session "Provide {language} best practices for {focus_area}"
-
-do review_code("Python", "performance")
-do review_code("TypeScript", "type safety")
-do review_code("Rust", "memory safety")
-
-# Parameterized block for data processing
-block process_dataset(source, format):
-  session "Load data from {source}"
-  session "Validate {format} structure"
-  session "Transform to standard format"
-  session "Generate quality report for {source} data"
-
-do process_dataset("sales_db", "CSV")
-do process_dataset("api_logs", "JSON")
-do process_dataset("user_events", "Parquet")
-
-# Blocks with parameters used in control flow
-block test_feature(feature_name, test_level):
-  session "Write {test_level} tests for {feature_name}"
-
-  if **the tests reveal issues**:
-    session "Fix issues in {feature_name}"
-    session "Re-run {test_level} tests for {feature_name}"
-  else:
-    session "Mark {feature_name} {test_level} testing complete"
-
-do test_feature("authentication", "unit")
-do test_feature("payment processing", "integration")
-do test_feature("user dashboard", "e2e")
-
-# Parameterized blocks in parallel
-block analyze_competitor(company):
-  session "Research {company} products"
-  session "Analyze {company} market position"
-  session "Identify {company} strengths and weaknesses"
-
-parallel:
-  a = do analyze_competitor("Company A")
-  b = do analyze_competitor("Company B")
-  c = do analyze_competitor("Company C")
-
-session "Create competitive analysis report"
-  context: { a, b, c }
-
-# Block with error handling
-block safe_api_call(endpoint, method):
-  try:
-    session "Call {endpoint} with {method} request"
-      retry: 3
-      backoff: "exponential"
-  catch as err:
-    session "Log failed {method} call to {endpoint}"
-      context: err
-    session "Return fallback response for {endpoint}"
-
-do safe_api_call("/users", "GET")
-do safe_api_call("/orders", "POST")
-do safe_api_call("/inventory", "PUT")
-
-# Nested block invocations
-block full_review(component):
-  do review_code("TypeScript", "security")
-  do test_feature(component, "unit")
-  session "Generate documentation for {component}"
-
-do full_review("UserService")
-do full_review("PaymentGateway")
-
-# Block with loop inside
-block process_batch(batch_name, items):
-  session "Start processing {batch_name}"
-  for item in items:
-    session "Process item from {batch_name}"
-      context: item
-  session "Complete {batch_name} processing"
-
-let batch1 = ["a", "b", "c"]
-let batch2 = ["x", "y", "z"]
-
-do process_batch("alpha", batch1)
-do process_batch("beta", batch2)

package/extensions/open-prose/skills/prose/examples/27-string-interpolation.prose

@@ -1,105 +0,0 @@
-# String Interpolation Example
-# Demonstrates dynamic prompt construction with {variable} syntax
-
-# Basic interpolation
-let user_name = session "Get the user's name"
-let topic = session "Ask what topic they want to learn about"
-
-session "Create a personalized greeting for {user_name} about {topic}"
-
-# Multiple interpolations in one prompt
-let company = session "Get the company name"
-let industry = session "Identify the company's industry"
-let size = session "Determine company size (startup/mid/enterprise)"
-
-session "Write a customized proposal for {company}, a {size} company in {industry}"
-
-# Interpolation with context
-let research = session "Research the topic thoroughly"
-
-session "Based on the research, explain {topic} to {user_name}"
-  context: research
-
-# Multi-line strings with interpolation
-let project = session "Get the project name"
-let deadline = session "Get the project deadline"
-let team_size = session "Get the team size"
-
-session """
-Create a project plan for {project}.
-
-Key constraints:
-- Deadline: {deadline}
-- Team size: {team_size}
-
-Include milestones and resource allocation.
-"""
-
-# Interpolation in loops
-let languages = ["Python", "JavaScript", "Go"]
-
-for lang in languages:
-  session "Write a hello world program in {lang}"
-  session "Explain the syntax of {lang}"
-
-# Interpolation in parallel blocks
-let regions = ["North America", "Europe", "Asia Pacific"]
-
-parallel for region in regions:
-  session "Analyze market conditions in {region}"
-  session "Identify top competitors in {region}"
-
-# Interpolation with computed values
-let base_topic = session "Get the main topic"
-let analysis = session "Analyze {base_topic} from multiple angles"
-
-let subtopics = ["history", "current state", "future trends"]
-for subtopic in subtopics:
-  session "Explore the {subtopic} of {base_topic}"
-    context: analysis
-
-# Building dynamic workflows
-let workflow_type = session "What type of document should we create?"
-let audience = session "Who is the target audience?"
-let length = session "How long should the document be?"
-
-session """
-Create a {workflow_type} for {audience}.
-
-Requirements:
-- Length: approximately {length}
-- Tone: appropriate for {audience}
-- Focus: practical and actionable
-
-Please structure with clear sections.
-"""
-
-# Interpolation in error messages
-let operation = session "Get the operation name"
-let target = session "Get the target resource"
-
-try:
-  session "Perform {operation} on {target}"
-catch:
-  session "Failed to {operation} on {target} - attempting recovery"
-  throw "Operation {operation} failed for {target}"
-
-# Combining interpolation with choice blocks
-let task_type = session "Identify the type of task"
-let priority = session "Determine task priority"
-
-choice **the best approach for a {priority} priority {task_type}**:
-  option "Immediate action":
-    session "Execute {task_type} immediately with {priority} priority handling"
-  option "Scheduled action":
-    session "Schedule {task_type} based on {priority} priority queue"
-  option "Delegate":
-    session "Assign {task_type} to appropriate team member"
-
-# Interpolation with agent definitions
-agent custom_agent:
-  model: sonnet
-  prompt: "You specialize in helping with {topic}"
-
-session: custom_agent
-  prompt: "Provide expert guidance on {topic} for {user_name}"

package/extensions/open-prose/skills/prose/examples/28-automated-pr-review.prose

@@ -1,37 +0,0 @@
-# Automated PR Review Workflow
-# This workflow performs a multi-dimensional review of a codebase changes.
-
-agent reviewer:
-  model: sonnet
-  prompt: "You are an expert software engineer specializing in code reviews."
-
-agent security_expert:
-  model: opus
-  prompt: "You are a security researcher specializing in finding vulnerabilities."
-
-agent performance_expert:
-  model: sonnet
-  prompt: "You are a performance engineer specializing in optimization."
-
-# 1. Initial overview
-let overview = session: reviewer
-  prompt: "Read the changes in the current directory and provide a high-level summary of the architectural impact."
-
-# 2. Parallel deep-dive reviews
-parallel:
-  security = session: security_expert
-    prompt: "Perform a deep security audit of the changes. Look for OWASP top 10 issues."
-    context: overview
-
-  perf = session: performance_expert
-    prompt: "Analyze the performance implications. Identify potential bottlenecks or regressions."
-    context: overview
-
-  style = session: reviewer
-    prompt: "Review for code style, maintainability, and adherence to best practices."
-    context: overview
-
-# 3. Synthesis and final recommendation
-session: reviewer
-  prompt: "Synthesize the security, performance, and style reviews into a final PR comment. Provide a clear 'Approve', 'Request Changes', or 'Comment' recommendation."
-  context: { security, perf, style, overview }