loudmouth-ai 0.1.0 → 0.2.0

package/extensions/open-prose/skills/prose/examples/34-content-pipeline.prose

@@ -1,204 +0,0 @@
-# Content Creation Pipeline
-#
-# From idea to published content in one run. Researches a topic in parallel,
-# writes a blog post, refines it through editorial review, and generates
-# social media posts. Watch an entire content operation happen automatically.
-#
-# Usage: Provide a topic and watch the content materialize.
-
-input topic: "The topic to create content about"
-input audience: "Target audience (e.g., 'developers', 'executives', 'general')"
-
-agent researcher:
-  model: opus          # Deep research requires reasoning
-  skills: ["web-search"]
-  prompt: """
-You are a research specialist. For any topic:
-1. Find authoritative sources
-2. Identify key facts and statistics
-3. Note interesting angles and hooks
-4. Cite your sources
-
-Return structured research with citations.
-"""
-
-agent writer:
-  model: opus          # Writing is hard work
-  prompt: """
-You are a skilled technical writer. You write:
-- Clear, engaging prose
-- Well-structured articles with headers
-- Content appropriate for the target audience
-- With a distinctive but professional voice
-
-Avoid jargon unless writing for experts.
-"""
-
-agent editor:
-  model: sonnet
-  persist: true
-  prompt: """
-You are a senior editor. You review content for:
-- Clarity and flow
-- Factual accuracy
-- Engagement and hook strength
-- Appropriate length and structure
-
-Be constructive. Suggest specific improvements.
-"""
-
-agent social-strategist:
-  model: sonnet
-  prompt: """
-You create social media content. For each platform:
-- Twitter/X: Punchy, hooks, threads if needed
-- LinkedIn: Professional, insight-focused
-- Hacker News: Technical, understated, genuine
-
-Match the culture of each platform. Never be cringe.
-"""
-
-# Phase 1: Parallel research from multiple angles
-session "Research phase starting for: {topic}"
-
-parallel:
-  core_research = session: researcher
-    prompt: """
-Deep research on: {topic}
-
-Find:
-- Current state of the art
-- Recent developments (last 6 months)
-- Key players and their positions
-- Statistics and data points
-"""
-
-  competitive_landscape = session: researcher
-    prompt: """
-Competitive/comparative research on: {topic}
-
-Find:
-- Alternative approaches or solutions
-- Pros and cons of different options
-- What experts recommend
-"""
-
-  human_interest = session: researcher
-    prompt: """
-Human interest research on: {topic}
-
-Find:
-- Real-world case studies
-- Success and failure stories
-- Quotes from practitioners
-- Surprising or counterintuitive findings
-"""
-
-# Phase 2: Synthesize research
-let research_synthesis = session "Synthesize all research"
-  prompt: """
-Combine all research into a unified brief:
-1. Key thesis/angle for the article
-2. Supporting evidence ranked by strength
-3. Narrative arc suggestion
-4. Potential hooks and headlines
-
-Target audience: {audience}
-"""
-  context: { core_research, competitive_landscape, human_interest }
-
-# Phase 3: Write first draft
-let draft = session: writer
-  prompt: """
-Write a blog post on: {topic}
-
-Target: {audience}
-Length: 1500-2000 words
-Structure: Hook, context, main points, examples, conclusion
-
-Use the research provided. Cite sources where appropriate.
-"""
-  context: research_synthesis
-
-# Phase 4: Editorial loop
-session: editor
-  prompt: "Beginning editorial review. I'll track revisions."
-
-loop until **the article meets publication standards** (max: 4):
-  let critique = resume: editor
-    prompt: """
-Review this draft critically:
-1. What works well?
-2. What needs improvement?
-3. Specific suggestions (be actionable)
-4. Overall verdict: READY / NEEDS_REVISION
-
-Be demanding but fair.
-"""
-    context: draft
-
-  if **the article needs revision**:
-    draft = session: writer
-      prompt: """
-Revise the article based on editorial feedback.
-Address each point specifically.
-Maintain what's working well.
-"""
-      context: { draft, critique }
-
-# Phase 5: Generate social media variants
-parallel:
-  twitter_content = session: social-strategist
-    prompt: """
-Create Twitter/X content to promote this article:
-1. Main announcement tweet (punchy, with hook)
-2. 5-tweet thread extracting key insights
-3. 3 standalone insight tweets for later
-
-Include placeholder for article link.
-"""
-    context: draft
-
-  linkedin_post = session: social-strategist
-    prompt: """
-Create a LinkedIn post for this article:
-- Professional but not boring
-- Lead with insight, not announcement
-- 150-300 words
-- End with genuine question for engagement
-"""
-    context: draft
-
-  hn_submission = session: social-strategist
-    prompt: """
-Create Hacker News submission:
-- Title: factual, not clickbait, <80 chars
-- Suggested comment: genuine, adds context, not promotional
-
-HN culture: technical, skeptical, hates marketing speak.
-"""
-    context: draft
-
-# Phase 6: Package everything
-output article = draft
-output social = { twitter_content, linkedin_post, hn_submission }
-
-resume: editor
-  prompt: """
-Content Pipeline Complete!
-
-Final package:
-1. Article: {draft length} words, {revision count} revisions
-2. Twitter: thread + standalone tweets
-3. LinkedIn: professional post
-4. HN: submission ready
-
-Recommended publication order:
-1. Publish article
-2. HN submission (wait for feedback)
-3. Twitter thread
-4. LinkedIn (next business day AM)
-
-All files saved to ./content-output/
-"""
-  context: { draft, twitter_content, linkedin_post, hn_submission }

package/extensions/open-prose/skills/prose/examples/35-feature-factory.prose

@@ -1,296 +0,0 @@
-# Feature Factory
-#
-# From user story to deployed feature. A captain agent coordinates a team
-# of specialists to design, implement, test, and document a complete feature.
-# Watch an entire engineering team's workflow automated.
-#
-# Usage: Describe a feature and watch it get built.
-
-input feature: "Description of the feature to implement"
-input codebase_context: "Brief description of the codebase (optional)"
-
-# The Captain: Coordinates everything, maintains context across the build
-agent captain:
-  model: sonnet
-  persist: project     # Remembers across features
-  prompt: """
-You are the Tech Lead coordinating feature development.
-
-Your responsibilities:
-- Break features into implementable tasks
-- Review all work before it merges
-- Maintain architectural consistency
-- Make technical decisions when needed
-- Keep the build moving forward
-
-You've worked on this codebase before. Reference prior decisions.
-"""
-
-# Specialists
-agent architect:
-  model: opus
-  prompt: """
-You are a software architect. You design systems that are:
-- Simple (no unnecessary complexity)
-- Extensible (but not over-engineered)
-- Consistent with existing patterns
-
-Produce clear technical designs with file paths and interfaces.
-"""
-
-agent implementer:
-  model: opus
-  prompt: """
-You are a senior developer. You write:
-- Clean, idiomatic code
-- Following existing project patterns
-- With clear variable names and structure
-- Minimal but sufficient comments
-
-You implement exactly what's specified, nothing more.
-"""
-
-agent tester:
-  model: sonnet
-  prompt: """
-You are a QA engineer. You write:
-- Unit tests for individual functions
-- Integration tests for workflows
-- Edge case tests
-- Clear test names that document behavior
-
-Aim for high coverage of the new code.
-"""
-
-agent documenter:
-  model: sonnet
-  prompt: """
-You are a technical writer. You create:
-- Clear API documentation
-- Usage examples
-- README updates
-- Inline JSDoc/docstrings where needed
-
-Match existing documentation style.
-"""
-
-# ============================================================================
-# Phase 1: Understand the codebase
-# ============================================================================
-
-session: captain
-  prompt: """
-Starting feature implementation: {feature}
-
-First, let me understand the current codebase.
-"""
-
-let codebase_analysis = session "Analyze codebase structure"
-  prompt: """
-Explore the codebase to understand:
-1. Directory structure and organization
-2. Key patterns used (state management, API style, etc.)
-3. Testing approach
-4. Where this feature would fit
-
-Use Glob and Read tools to explore. Be thorough but efficient.
-"""
-  context: codebase_context
-
-# ============================================================================
-# Phase 2: Design
-# ============================================================================
-
-let design = session: architect
-  prompt: """
-Design the implementation for: {feature}
-
-Based on the codebase analysis, produce:
-1. High-level approach (2-3 sentences)
-2. Files to create/modify (with paths)
-3. Key interfaces/types to define
-4. Integration points with existing code
-5. Potential risks or decisions needed
-
-Keep it simple. Match existing patterns.
-"""
-  context: { feature, codebase_analysis }
-
-# Captain reviews design
-let design_approved = resume: captain
-  prompt: """
-Review this design:
-- Does it fit our architecture?
-- Is it the simplest approach?
-- Any risks or concerns?
-- Any decisions I need to make?
-
-Return APPROVED or specific concerns.
-"""
-  context: design
-
-if **design needs adjustment**:
-  design = session: architect
-    prompt: "Revise design based on tech lead feedback"
-    context: { design, design_approved }
-
-# ============================================================================
-# Phase 3: Implementation
-# ============================================================================
-
-resume: captain
-  prompt: "Design approved. Breaking into implementation tasks."
-  context: design
-
-let tasks = resume: captain
-  prompt: """
-Break the design into ordered implementation tasks.
-Each task should be:
-- Small enough to implement in one session
-- Have clear acceptance criteria
-- List file(s) to modify
-
-Return as numbered list with dependencies.
-"""
-  context: design
-
-# Implement each task sequentially
-for task in tasks:
-  resume: captain
-    prompt: "Starting task: {task}"
-
-  let implementation = session: implementer
-    prompt: """
-Implement this task:
-{task}
-
-Follow the design spec. Match existing code patterns.
-Write the actual code using Edit/Write tools.
-"""
-    context: { task, design, codebase_analysis }
-    retry: 2
-    backoff: exponential
-
-  # Captain reviews each piece
-  let review = resume: captain
-    prompt: """
-Review this implementation:
-- Does it match the design?
-- Code quality acceptable?
-- Any issues to fix before continuing?
-
-Be specific if changes needed.
-"""
-    context: { task, implementation }
-
-  if **implementation needs fixes**:
-    session: implementer
-      prompt: "Fix issues noted in review"
-      context: { implementation, review }
-
-# ============================================================================
-# Phase 4: Testing
-# ============================================================================
-
-resume: captain
-  prompt: "Implementation complete. Starting test phase."
-
-let tests = session: tester
-  prompt: """
-Write tests for the new feature:
-1. Unit tests for new functions/methods
-2. Integration tests for the feature flow
-3. Edge cases and error handling
-
-Use the project's existing test framework and patterns.
-Actually create the test files.
-"""
-  context: { design, codebase_analysis }
-
-# Run tests
-let test_results = session "Run test suite"
-  prompt: """
-Run all tests:
-1. npm test / pytest / cargo test (whatever this project uses)
-2. Report results
-3. If failures, identify which tests failed and why
-"""
-
-loop until **all tests pass** (max: 5):
-  if **tests are failing**:
-    let fix = session: implementer
-      prompt: "Fix failing tests. Either fix the code or fix the test if it's wrong."
-      context: test_results
-
-    test_results = session "Re-run tests after fix"
-      prompt: "Run tests again and report results"
-
-# ============================================================================
-# Phase 5: Documentation
-# ============================================================================
-
-resume: captain
-  prompt: "Tests passing. Final phase: documentation."
-
-parallel:
-  api_docs = session: documenter
-    prompt: """
-Document the new feature's API:
-- Function/method signatures
-- Parameters and return values
-- Usage examples
-- Add to existing docs structure
-"""
-    context: design
-
-  readme_update = session: documenter
-    prompt: """
-Update README if needed:
-- Add feature to feature list
-- Add usage example if user-facing
-- Update any outdated sections
-"""
-    context: { design, codebase_analysis }
-
-# ============================================================================
-# Phase 6: Final Review & Commit
-# ============================================================================
-
-resume: captain
-  prompt: """
-Feature complete! Final review:
-
-1. All tasks implemented
-2. Tests passing
-3. Documentation updated
-
-Prepare final summary and create commit.
-"""
-  context: { design, tests, api_docs }
-
-session "Create feature commit"
-  prompt: """
-Stage all changes and create a well-structured commit:
-1. git add -A
-2. git commit with message following conventional commits:
-   feat: {feature short description}
-
-   - Implementation details
-   - Tests added
-   - Docs updated
-"""
-
-# Final report
-output summary = resume: captain
-  prompt: """
-Feature Factory Complete!
-
-Generate final report:
-- Feature: {feature}
-- Files created/modified: [list]
-- Tests added: [count]
-- Time from start to finish
-- Any notes for future work
-
-This feature is ready for PR review.
-"""