loudmouth-ai 0.1.0 → 0.2.0

package/extensions/open-prose/skills/prose/examples/29-captains-chair.prose

@@ -1,218 +0,0 @@
-# The Captain's Chair
-#
-# A project management orchestration pattern where a prime agent dispatches
-# specialized subagents for all coding, validation, and task execution.
-# The captain never writes code directly—only coordinates, validates, and
-# maintains strategic oversight.
-#
-# Key principles:
-# - Context isolation: Subagents receive targeted context, not everything
-# - Parallel execution: Multiple subagents work concurrently where possible
-# - Critic agents: Continuous review of plans and outputs
-# - Checkpoint validation: User approval at key decision points
-
-input task: "The feature or task to implement"
-input codebase_context: "Brief description of the codebase and relevant files"
-
-# ============================================================================
-# Agent Definitions: The Crew
-# ============================================================================
-
-# The Captain: Orchestrates but never codes
-agent captain:
-  model: opus
-  prompt: """You are a senior engineering manager. You NEVER write code directly.
-Your job is to:
-- Break down complex tasks into discrete work items
-- Dispatch work to appropriate specialists
-- Validate that outputs meet requirements
-- Maintain strategic alignment with user intent
-- Identify blockers and escalate decisions to the user
-
-Always think about: What context does each subagent need? What can run in parallel?
-What needs human validation before proceeding?"""
-
-# Research agents - fast, focused information gathering
-agent researcher:
-  model: haiku
-  prompt: """You are a research specialist. Find specific information quickly.
-Provide concise, actionable findings. Cite file paths and line numbers."""
-
-# Coding agents - implementation specialists
-agent coder:
-  model: sonnet
-  prompt: """You are an expert software engineer. Write clean, idiomatic code.
-Follow existing patterns in the codebase. No over-engineering."""
-
-# Critic agents - continuous quality review
-agent critic:
-  model: sonnet
-  prompt: """You are a senior code reviewer and architect. Your job is to find:
-- Logic errors and edge cases
-- Security vulnerabilities
-- Performance issues
-- Deviations from best practices
-- Unnecessary complexity
-Be constructive but thorough. Prioritize issues by severity."""
-
-# Test agent - validation specialist
-agent tester:
-  model: sonnet
-  prompt: """You are a QA engineer. Write comprehensive tests.
-Focus on edge cases and failure modes. Ensure test isolation."""
-
-# ============================================================================
-# Block Definitions: Reusable Operations
-# ============================================================================
-
-# Parallel research sweep - gather all context simultaneously
-block research-sweep(topic):
-  parallel (on-fail: "continue"):
-    docs = session: researcher
-      prompt: "Find relevant documentation and README files for: {topic}"
-    code = session: researcher
-      prompt: "Find existing code patterns and implementations related to: {topic}"
-    tests = session: researcher
-      prompt: "Find existing tests that cover functionality similar to: {topic}"
-    issues = session: researcher
-      prompt: "Search for related issues, TODOs, or known limitations for: {topic}"
-
-# Parallel code review - multiple perspectives simultaneously
-block review-cycle(code_changes):
-  parallel:
-    security = session: critic
-      prompt: "Review for security vulnerabilities and injection risks"
-      context: code_changes
-    correctness = session: critic
-      prompt: "Review for logic errors, edge cases, and correctness"
-      context: code_changes
-    style = session: critic
-      prompt: "Review for code style, readability, and maintainability"
-      context: code_changes
-    perf = session: critic
-      prompt: "Review for performance issues and optimization opportunities"
-      context: code_changes
-
-# Implementation cycle with built-in critic
-block implement-with-review(implementation_plan):
-  let code = session: coder
-    prompt: "Implement according to the plan"
-    context: implementation_plan
-
-  let review = do review-cycle(code)
-
-  if **critical issues found in review**:
-    let fixed = session: coder
-      prompt: "Address the critical issues identified in the review"
-      context: { code, review }
-    output result = fixed
-  else:
-    output result = code
-
-# ============================================================================
-# Main Workflow: The Captain's Chair in Action
-# ============================================================================
-
-# Phase 1: Strategic Planning
-# ---------------------------
-# The captain breaks down the task and identifies what information is needed
-
-let breakdown = session: captain
-  prompt: """Analyze this task and create a strategic plan:
-
-Task: {task}
-Codebase: {codebase_context}
-
-Output:
-1. List of discrete work items (what code needs to be written/changed)
-2. Dependencies between work items (what must complete before what)
-3. What can be parallelized
-4. Key questions that need user input before proceeding
-5. Risks and potential blockers"""
-
-# Phase 2: Parallel Research Sweep
-# --------------------------------
-# Dispatch researchers to gather all necessary context simultaneously
-
-do research-sweep(task)
-
-# Phase 3: Plan Synthesis and Critic Review
-# -----------------------------------------
-# Captain synthesizes research into implementation plan, critic reviews it
-
-let implementation_plan = session: captain
-  prompt: """Synthesize the research into a detailed implementation plan.
-
-Research findings:
-{docs}
-{code}
-{tests}
-{issues}
-
-For each work item, specify:
-- Exact files to modify
-- Code patterns to follow
-- Tests to add or update
-- Integration points"""
-  context: { breakdown, docs, code, tests, issues }
-
-# Critic reviews the plan BEFORE implementation begins
-let plan_review = session: critic
-  prompt: """Review this implementation plan for:
-- Missing edge cases
-- Architectural concerns
-- Testability issues
-- Scope creep
-- Unclear requirements that need user clarification"""
-  context: implementation_plan
-
-# Checkpoint: User validates plan before execution
-if **the plan review raised critical concerns**:
-  let revised_plan = session: captain
-    prompt: "Revise the plan based on critic feedback"
-    context: { implementation_plan, plan_review }
-  # Continue with revised plan
-  let final_plan = revised_plan
-else:
-  let final_plan = implementation_plan
-
-# Phase 4: Parallel Implementation
-# --------------------------------
-# Identify independent work items and execute in parallel where possible
-
-let work_items = session: captain
-  prompt: "Extract the independent work items that can be done in parallel from this plan"
-  context: final_plan
-
-# Execute independent items in parallel, each with its own review cycle
-parallel (on-fail: "continue"):
-  impl_a = do implement-with-review(work_items)
-  impl_b = session: tester
-    prompt: "Write tests for the planned functionality"
-    context: { final_plan, code }
-
-# Phase 5: Integration and Final Review
-# -------------------------------------
-# Captain validates all pieces fit together
-
-let integration = session: captain
-  prompt: """Review all implementation results and verify:
-1. All work items completed successfully
-2. Tests cover the new functionality
-3. No merge conflicts or integration issues
-4. Documentation updated if needed
-
-Summarize what was done and any remaining items."""
-  context: { impl_a, impl_b, final_plan }
-
-# Final critic pass on complete implementation
-let final_review = do review-cycle(integration)
-
-if **final review passed**:
-  output result = session: captain
-    prompt: "Prepare final summary for user: what was implemented, tests added, and next steps"
-    context: { integration, final_review }
-else:
-  output result = session: captain
-    prompt: "Summarize what was completed and what issues remain for user attention"
-    context: { integration, final_review }

package/extensions/open-prose/skills/prose/examples/30-captains-chair-simple.prose

@@ -1,42 +0,0 @@
-# Simple Captain's Chair
-#
-# The minimal captain's chair pattern: a coordinating agent that dispatches
-# subagents for all execution. The captain only plans and validates.
-
-input task: "What to accomplish"
-
-# The captain coordinates but never executes
-agent captain:
-  model: opus
-  prompt: "You are a project coordinator. Never write code directly. Break down tasks, dispatch to specialists, validate results."
-
-agent executor:
-  model: opus
-  prompt: "You are a skilled implementer. Execute the assigned task precisely."
-
-agent critic:
-  model: opus
-  prompt: "You are a critic. Find issues, suggest improvements. Be thorough."
-
-# Step 1: Captain creates the plan
-let plan = session: captain
-  prompt: "Break down this task into work items: {task}"
-
-# Step 2: Dispatch parallel execution
-parallel:
-  work = session: executor
-    prompt: "Execute the plan"
-    context: plan
-  review = session: critic
-    prompt: "Identify potential issues with this approach"
-    context: plan
-
-# Step 3: Captain synthesizes and validates
-if **critic found issues that affect the work**:
-  output result = session: captain
-    prompt: "Integrate the work while addressing critic's concerns"
-    context: { work, review }
-else:
-  output result = session: captain
-    prompt: "Validate and summarize the completed work"
-    context: { work, review }

package/extensions/open-prose/skills/prose/examples/31-captains-chair-with-memory.prose

@@ -1,145 +0,0 @@
-# Captain's Chair with Memory and Self-Improvement
-#
-# An advanced orchestration pattern that includes:
-# - Retrospective analysis after task completion
-# - Learning from mistakes to improve future runs
-# - Continuous critic supervision during execution
-#
-# From the blog post: "Future agents will flip the plan:execute paradigm
-# to 80:20 from today's 20:80"
-
-input task: "The task to accomplish"
-input past_learnings: "Previous session learnings (if any)"
-
-# ============================================================================
-# Agent Definitions
-# ============================================================================
-
-agent captain:
-  model: opus
-  prompt: """You are a senior engineering manager. You coordinate but never code directly.
-
-Your responsibilities:
-1. Strategic planning with 80% of effort on planning, 20% on execution oversight
-2. Dispatch specialized subagents for all implementation
-3. Validate outputs meet requirements
-4. Learn from each session to improve future runs
-
-Past learnings to incorporate:
-{past_learnings}"""
-
-agent planner:
-  model: opus
-  prompt: """You are a meticulous planner. Create implementation plans with:
-- Exact files and line numbers to modify
-- Code patterns to follow from existing codebase
-- Edge cases to handle
-- Tests to write"""
-
-agent researcher:
-  model: haiku
-  prompt: "Find specific information quickly. Cite sources."
-
-agent executor:
-  model: sonnet
-  prompt: "Implement precisely according to plan. Follow existing patterns."
-
-agent critic:
-  model: sonnet
-  prompt: """You are a continuous critic. Your job is to watch execution and flag:
-- Deviations from plan
-- Emerging issues
-- Opportunities for improvement
-Be proactive - don't wait for completion to raise concerns."""
-
-agent retrospective:
-  model: opus
-  prompt: """You analyze completed sessions to extract learnings:
-- What went well?
-- What could be improved?
-- What should be remembered for next time?
-Output actionable insights, not platitudes."""
-
-# ============================================================================
-# Phase 1: Deep Planning (80% of effort)
-# ============================================================================
-
-# Parallel research - gather everything needed upfront
-parallel:
-  codebase = session: researcher
-    prompt: "Map the relevant parts of the codebase for: {task}"
-  patterns = session: researcher
-    prompt: "Find coding patterns and conventions used in this repo"
-  docs = session: researcher
-    prompt: "Find documentation and prior decisions related to: {task}"
-  issues = session: researcher
-    prompt: "Find known issues, TODOs, and edge cases for: {task}"
-
-# Create detailed implementation plan
-let detailed_plan = session: planner
-  prompt: """Create a comprehensive implementation plan for: {task}
-
-Use the research to specify:
-1. Exact changes needed (file:line format)
-2. Code patterns to follow
-3. Edge cases from prior issues
-4. Test coverage requirements"""
-  context: { codebase, patterns, docs, issues }
-
-# Critic reviews plan BEFORE execution
-let plan_critique = session: critic
-  prompt: "Review this plan for gaps, risks, and unclear requirements"
-  context: detailed_plan
-
-# Captain decides if plan needs revision
-if **plan critique identified blocking issues**:
-  let revised_plan = session: planner
-    prompt: "Revise the plan to address critique"
-    context: { detailed_plan, plan_critique }
-else:
-  let revised_plan = detailed_plan
-
-# ============================================================================
-# Phase 2: Supervised Execution (20% of effort)
-# ============================================================================
-
-# Execute with concurrent critic supervision
-parallel:
-  implementation = session: executor
-    prompt: "Implement according to the plan"
-    context: revised_plan
-  live_critique = session: critic
-    prompt: "Monitor implementation for deviations and emerging issues"
-    context: revised_plan
-
-# Captain validates and integrates
-let validated = session: captain
-  prompt: """Validate the implementation:
-- Does it match the plan?
-- Were critic's live concerns addressed?
-- Is it ready for user review?"""
-  context: { implementation, live_critique, revised_plan }
-
-# ============================================================================
-# Phase 3: Retrospective and Learning
-# ============================================================================
-
-# Extract learnings for future sessions
-let session_learnings = session: retrospective
-  prompt: """Analyze this completed session:
-
-Plan: {revised_plan}
-Implementation: {implementation}
-Critique: {live_critique}
-Validation: {validated}
-
-Extract:
-1. What patterns worked well?
-2. What caused friction or rework?
-3. What should the captain remember next time?
-4. Any codebase insights to preserve?"""
-  context: { revised_plan, implementation, live_critique, validated }
-
-# Output both the result and the learnings
-output result = validated
-output learnings = session_learnings

package/extensions/open-prose/skills/prose/examples/33-pr-review-autofix.prose

@@ -1,168 +0,0 @@
-# PR Review + Auto-Fix
-#
-# A self-healing code review pipeline. Reviews a PR from multiple angles,
-# identifies issues, and automatically fixes them in a loop until the
-# review passes. Satisfying to watch as issues get knocked down one by one.
-#
-# Usage: Run against any open PR in your repo.
-
-agent reviewer:
-  model: sonnet
-  prompt: """
-You are a senior code reviewer. You review code for:
-- Correctness and logic errors
-- Security vulnerabilities
-- Performance issues
-- Code style and readability
-
-Be specific. Reference exact file paths and line numbers.
-Return a structured list of issues or "APPROVED" if none found.
-"""
-
-agent security-reviewer:
-  model: opus          # Security requires deep reasoning
-  prompt: """
-You are a security specialist. Focus exclusively on:
-- Injection vulnerabilities (SQL, command, XSS)
-- Authentication/authorization flaws
-- Data exposure and privacy issues
-- Cryptographic weaknesses
-
-If you find issues, they are HIGH priority. Be thorough.
-"""
-
-agent fixer:
-  model: opus          # Fixing requires understanding + execution
-  prompt: """
-You are a code fixer. Given an issue report:
-1. Understand the root cause
-2. Implement the minimal fix
-3. Verify the fix addresses the issue
-4. Create a clean commit
-
-Do NOT over-engineer. Fix exactly what's reported, nothing more.
-"""
-
-agent captain:
-  model: sonnet        # Orchestration role
-  persist: true
-  prompt: """
-You coordinate the PR review process. You:
-- Track which issues have been found and fixed
-- Decide when the PR is ready to merge
-- Escalate to human if something is unfixable
-"""
-
-# Get the PR diff
-let pr_diff = session "Fetch the PR diff"
-  prompt: """
-Read the current PR:
-1. Run: gh pr diff
-2. Also get: gh pr view --json title,body,files
-3. Return the complete diff and PR metadata
-"""
-
-# Phase 1: Parallel multi-perspective review
-session: captain
-  prompt: "Starting PR review. I'll coordinate multiple reviewers."
-
-parallel:
-  general_review = session: reviewer
-    prompt: "Review this PR for correctness, logic, and style issues"
-    context: pr_diff
-
-  security_review = session: security-reviewer
-    prompt: "Security audit this PR. Flag any vulnerabilities."
-    context: pr_diff
-
-  test_check = session "Check test coverage"
-    prompt: """
-Analyze the PR:
-1. What code changed?
-2. Are there tests for the changes?
-3. Run existing tests: npm test / pytest / cargo test
-Return: test status and coverage gaps
-"""
-    context: pr_diff
-
-# Phase 2: Captain synthesizes and prioritizes
-let issues = resume: captain
-  prompt: """
-Synthesize all review feedback into a prioritized issue list.
-Format each issue as:
-- ID: issue-N
-- Severity: critical/high/medium/low
-- File: path/to/file.ts
-- Line: 42
-- Issue: description
-- Fix: suggested approach
-
-If all reviews passed, return "ALL_CLEAR".
-"""
-  context: { general_review, security_review, test_check }
-
-# Phase 3: Auto-fix loop
-loop until **all issues are resolved or unfixable** (max: 10):
-
-  if **there are no remaining issues**:
-    resume: captain
-      prompt: "All issues resolved! Summarize what was fixed."
-  else:
-    # Pick the highest priority unfixed issue
-    let current_issue = resume: captain
-      prompt: "Select the next highest priority issue to fix."
-      context: issues
-
-    # Attempt the fix
-    try:
-      session: fixer
-        prompt: """
-Fix this issue:
-{current_issue}
-
-Steps:
-1. Read the file
-2. Understand the context
-3. Implement the fix
-4. Run tests to verify
-5. Commit with message: "fix: [issue description]"
-"""
-        context: current_issue
-        retry: 2
-        backoff: exponential
-
-      # Mark as fixed
-      resume: captain
-        prompt: "Issue fixed. Update tracking and check remaining issues."
-        context: current_issue
-
-    catch as fix_error:
-      # Escalate unfixable issues
-      resume: captain
-        prompt: """
-Fix attempt failed. Determine if this is:
-1. Retryable with different approach
-2. Needs human intervention
-3. A false positive (not actually an issue)
-
-Update issue status accordingly.
-"""
-        context: { current_issue, fix_error }
-
-# Phase 4: Final verification
-let final_review = session: reviewer
-  prompt: "Final review pass. Verify all fixes are correct and complete."
-
-resume: captain
-  prompt: """
-PR Review Complete!
-
-Generate final report:
-- Issues found: N
-- Issues fixed: N
-- Issues requiring human review: N
-- Recommendation: MERGE / NEEDS_ATTENTION / BLOCK
-
-If ready, run: gh pr review --approve
-"""
-  context: final_review