392 lines
14 KiB
Markdown
392 lines
14 KiB
Markdown
# OpenProse Examples
|
|
|
|
These examples demonstrate workflows using OpenProse's full feature set.
|
|
|
|
## Available Examples
|
|
|
|
### Basics (01-08)
|
|
|
|
| File | Description |
|
|
| --------------------------------- | -------------------------------------------- |
|
|
| `01-hello-world.prose` | Simplest possible program - a single session |
|
|
| `02-research-and-summarize.prose` | Research a topic, then summarize findings |
|
|
| `03-code-review.prose` | Multi-perspective code review pipeline |
|
|
| `04-write-and-refine.prose` | Draft content and iteratively improve it |
|
|
| `05-debug-issue.prose` | Step-by-step debugging workflow |
|
|
| `06-explain-codebase.prose` | Progressive exploration of a codebase |
|
|
| `07-refactor.prose` | Systematic refactoring workflow |
|
|
| `08-blog-post.prose` | End-to-end content creation |
|
|
|
|
### Agents & Skills (09-12)
|
|
|
|
| File | Description |
|
|
| ----------------------------------- | ------------------------------------ |
|
|
| `09-research-with-agents.prose` | Custom agents with model selection |
|
|
| `10-code-review-agents.prose` | Specialized reviewer agents |
|
|
| `11-skills-and-imports.prose` | External skill imports |
|
|
| `12-secure-agent-permissions.prose` | Agent permissions and access control |
|
|
|
|
### Variables & Composition (13-15)
|
|
|
|
| File | Description |
|
|
| -------------------------------- | ----------------------------------- |
|
|
| `13-variables-and-context.prose` | let/const bindings, context passing |
|
|
| `14-composition-blocks.prose` | Named blocks, do blocks |
|
|
| `15-inline-sequences.prose` | Arrow operator chains |
|
|
|
|
### Parallel Execution (16-19)
|
|
|
|
| File | Description |
|
|
| ------------------------------------ | ----------------------------------------- |
|
|
| `16-parallel-reviews.prose` | Basic parallel execution |
|
|
| `17-parallel-research.prose` | Named parallel results |
|
|
| `18-mixed-parallel-sequential.prose` | Combined parallel and sequential patterns |
|
|
| `19-advanced-parallel.prose` | Join strategies, failure policies |
|
|
|
|
### Loops (20)
|
|
|
|
| File | Description |
|
|
| ---------------------- | --------------------------------------- |
|
|
| `20-fixed-loops.prose` | repeat, for-each, parallel for patterns |
|
|
|
|
### Pipelines (21)
|
|
|
|
| File | Description |
|
|
| ------------------------------ | ----------------------------------------- |
|
|
| `21-pipeline-operations.prose` | map, filter, reduce, pmap transformations |
|
|
|
|
### Error Handling (22-23)
|
|
|
|
| File | Description |
|
|
| ----------------------------- | -------------------------------------- |
|
|
| `22-error-handling.prose` | try/catch/finally patterns |
|
|
| `23-retry-with-backoff.prose` | Resilient API calls with retry/backoff |
|
|
|
|
### Advanced Features (24-27)
|
|
|
|
| File | Description |
|
|
| ------------------------------- | --------------------------------- |
|
|
| `24-choice-blocks.prose` | AI-selected branching |
|
|
| `25-conditionals.prose` | if/elif/else patterns |
|
|
| `26-parameterized-blocks.prose` | Reusable blocks with arguments |
|
|
| `27-string-interpolation.prose` | Dynamic prompts with {var} syntax |
|
|
|
|
### Orchestration Systems (28-31)
|
|
|
|
| File | Description |
|
|
| ------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
|
| `28-gas-town.prose` | Multi-agent orchestration ("Kubernetes for agents") with 7 worker roles, patrols, convoys, and GUPP propulsion |
|
|
| `29-captains-chair.prose` | Full captain's chair pattern: coordinating agent dispatches subagents for all work, with parallel research, critic review cycles, and checkpoint validation |
|
|
| `30-captains-chair-simple.prose` | Minimal captain's chair: core pattern without complexity |
|
|
| `31-captains-chair-with-memory.prose` | Captain's chair with retrospective analysis and session-to-session learning |
|
|
|
|
### Production Workflows (33-38)
|
|
|
|
| File | Description |
|
|
| ---------------------------- | ---------------------------------------- |
|
|
| `33-pr-review-autofix.prose` | Automated PR review with fix suggestions |
|
|
| `34-content-pipeline.prose` | End-to-end content creation pipeline |
|
|
| `35-feature-factory.prose` | Feature implementation automation |
|
|
| `36-bug-hunter.prose` | Systematic bug detection and analysis |
|
|
| `37-the-forge.prose` | Build a browser from scratch |
|
|
| `38-skill-scan.prose` | Skill discovery and analysis |
|
|
|
|
### Architecture Patterns (39)
|
|
|
|
| File | Description |
|
|
| ---------------------------------- | ---------------------------------------------------------------------------------------------------- |
|
|
| `39-architect-by-simulation.prose` | Design systems through simulated implementation phases with serial handoffs and persistent architect |
|
|
|
|
### Recursive Language Models (40-43)
|
|
|
|
| File | Description |
|
|
| ----------------------------- | ------------------------------------------------------------------- |
|
|
| `40-rlm-self-refine.prose` | Recursive refinement until quality threshold - the core RLM pattern |
|
|
| `41-rlm-divide-conquer.prose` | Hierarchical chunking for inputs beyond context limits |
|
|
| `42-rlm-filter-recurse.prose` | Filter-then-process for needle-in-haystack tasks |
|
|
| `43-rlm-pairwise.prose` | O(n^2) pairwise aggregation for relationship mapping |
|
|
|
|
### Meta / Self-Hosting (44-48)
|
|
|
|
| File | Description |
|
|
| --------------------------------- | ------------------------------------------------------ |
|
|
| `44-run-endpoint-ux-test.prose` | Concurrent agents testing the /run API endpoint |
|
|
| `45-plugin-release.prose` | OpenProse plugin release workflow (this repo) |
|
|
| `46-workflow-crystallizer.prose` | Reflective: observes thread, extracts workflow, writes .prose |
|
|
| `47-language-self-improvement.prose` | Meta-level 2: analyzes .prose corpus to evolve the language itself |
|
|
| `48-habit-miner.prose` | Mines AI session logs for patterns, generates .prose automations |
|
|
|
|
## The Architect By Simulation Pattern
|
|
|
|
The architect-by-simulation pattern is for designing systems by "implementing" them through reasoning. Instead of writing code, each phase produces specification documents that the next phase builds upon.
|
|
|
|
**Key principles:**
|
|
|
|
1. **Thinking/deduction framework**: "Implement" means reasoning through design decisions
|
|
2. **Serial pipeline with handoffs**: Each phase reads previous phase's output
|
|
3. **Persistent architect**: Maintains master plan and synthesizes learnings
|
|
4. **User checkpoint**: Get plan approval BEFORE executing the pipeline
|
|
5. **Simulation as implementation**: The spec IS the deliverable
|
|
|
|
```prose
|
|
# The core pattern
|
|
agent architect:
|
|
model: opus
|
|
persist: true
|
|
prompt: "Design by simulating implementation"
|
|
|
|
# Create master plan with phases
|
|
let plan = session: architect
|
|
prompt: "Break feature into design phases"
|
|
|
|
# User reviews the plan BEFORE the pipeline runs
|
|
input user_approval: "User reviews plan and approves"
|
|
|
|
# Execute phases serially with handoffs
|
|
for phase_name, index in phases:
|
|
let handoff = session: phase-executor
|
|
prompt: "Execute phase {index}"
|
|
context: previous_handoffs
|
|
|
|
# Architect synthesizes after each phase
|
|
resume: architect
|
|
prompt: "Synthesize learnings from phase {index}"
|
|
context: handoff
|
|
|
|
# Synthesize all handoffs into final spec
|
|
output spec = session: architect
|
|
prompt: "Synthesize all handoffs into final spec"
|
|
```
|
|
|
|
See example 39 for the full implementation.
|
|
|
|
## The Captain's Chair Pattern
|
|
|
|
The captain's chair is an orchestration paradigm where a coordinating agent (the "captain") dispatches specialized subagents for all execution. The captain never writes code directly—only plans, coordinates, and validates.
|
|
|
|
**Key principles:**
|
|
|
|
1. **Context isolation**: Subagents receive targeted context, not everything
|
|
2. **Parallel execution**: Multiple subagents work concurrently where possible
|
|
3. **Continuous criticism**: Critic agents review plans and outputs mid-stream
|
|
4. **80/20 planning**: 80% effort on planning, 20% on execution oversight
|
|
5. **Checkpoint validation**: User approval at key decision points
|
|
|
|
```prose
|
|
# The core pattern
|
|
agent captain:
|
|
model: opus
|
|
prompt: "Coordinate but never execute directly"
|
|
|
|
agent executor:
|
|
model: sonnet
|
|
prompt: "Execute assigned tasks precisely"
|
|
|
|
agent critic:
|
|
model: sonnet
|
|
prompt: "Review work and find issues"
|
|
|
|
# Captain plans
|
|
let plan = session: captain
|
|
prompt: "Break down this task"
|
|
|
|
# Parallel execution with criticism
|
|
parallel:
|
|
work = session: executor
|
|
context: plan
|
|
review = session: critic
|
|
context: plan
|
|
|
|
# Captain validates
|
|
output result = session: captain
|
|
prompt: "Validate and integrate"
|
|
context: { work, review }
|
|
```
|
|
|
|
See examples 29-31 for full implementations.
|
|
|
|
## The Recursive Language Model Pattern
|
|
|
|
Recursive Language Models (RLMs) are a paradigm for handling inputs far beyond context limits. The key insight: treat the prompt as an external environment that the LLM can symbolically interact with, chunk, and recursively process.
|
|
|
|
**Why RLMs matter:**
|
|
|
|
- Base LLMs degrade rapidly on long contexts ("context rot")
|
|
- RLMs maintain performance on inputs 2 orders of magnitude beyond context limits
|
|
- On quadratic-complexity tasks, base models get <0.1% while RLMs achieve 58%
|
|
|
|
**Key patterns:**
|
|
|
|
1. **Self-refinement**: Recursive improvement until quality threshold
|
|
2. **Divide-and-conquer**: Chunk, process, aggregate recursively
|
|
3. **Filter-then-recurse**: Cheap filtering before expensive deep dives
|
|
4. **Pairwise aggregation**: Handle O(n²) tasks through batch decomposition
|
|
|
|
```prose
|
|
# The core RLM pattern: recursive block with scope isolation
|
|
block process(data, depth):
|
|
# Base case
|
|
if **data is small** or depth <= 0:
|
|
output session "Process directly"
|
|
context: data
|
|
|
|
# Recursive case: chunk and fan out
|
|
let chunks = session "Split into logical chunks"
|
|
context: data
|
|
|
|
parallel for chunk in chunks:
|
|
do process(chunk, depth - 1) # Recursive call
|
|
|
|
# Aggregate results (fan in)
|
|
output session "Synthesize partial results"
|
|
```
|
|
|
|
**OpenProse advantages for RLMs:**
|
|
|
|
- **Scope isolation**: Each recursive call gets its own `execution_id`, preventing variable collisions
|
|
- **Parallel fan-out**: `parallel for` enables concurrent processing at each recursion level
|
|
- **State persistence**: SQLite/PostgreSQL backends track the full call tree
|
|
- **Natural aggregation**: Pipelines (`| reduce`) and explicit context passing
|
|
|
|
See examples 40-43 for full implementations.
|
|
|
|
## Running Examples
|
|
|
|
Ask Claude to run any example:
|
|
|
|
```
|
|
Run the code review example from the OpenProse examples
|
|
```
|
|
|
|
Or reference the file directly:
|
|
|
|
```
|
|
Execute examples/03-code-review.prose
|
|
```
|
|
|
|
## Feature Reference
|
|
|
|
### Core Syntax
|
|
|
|
```prose
|
|
# Comments
|
|
session "prompt" # Simple session
|
|
let x = session "..." # Variable binding
|
|
const y = session "..." # Immutable binding
|
|
```
|
|
|
|
### Agents
|
|
|
|
```prose
|
|
agent name:
|
|
model: sonnet # haiku, sonnet, opus
|
|
prompt: "System prompt"
|
|
skills: ["skill1", "skill2"]
|
|
permissions:
|
|
read: ["*.md"]
|
|
bash: deny
|
|
```
|
|
|
|
### Parallel
|
|
|
|
```prose
|
|
parallel: # Basic parallel
|
|
a = session "A"
|
|
b = session "B"
|
|
|
|
parallel ("first"): # Race - first wins
|
|
parallel ("any", count: 2): # Wait for N successes
|
|
parallel (on-fail: "continue"): # Don't fail on errors
|
|
```
|
|
|
|
### Loops
|
|
|
|
```prose
|
|
repeat 3: # Fixed iterations
|
|
session "..."
|
|
|
|
for item in items: # For-each
|
|
session "..."
|
|
|
|
parallel for item in items: # Parallel for-each
|
|
session "..."
|
|
|
|
loop until **condition** (max: 10): # Unbounded with AI condition
|
|
session "..."
|
|
```
|
|
|
|
### Pipelines
|
|
|
|
```prose
|
|
items | map: # Transform each
|
|
session "..."
|
|
items | filter: # Keep matching
|
|
session "..."
|
|
items | reduce(acc, x): # Accumulate
|
|
session "..."
|
|
items | pmap: # Parallel transform
|
|
session "..."
|
|
```
|
|
|
|
### Error Handling
|
|
|
|
```prose
|
|
try:
|
|
session "..."
|
|
catch as err:
|
|
session "..."
|
|
finally:
|
|
session "..."
|
|
|
|
session "..."
|
|
retry: 3
|
|
backoff: "exponential" # none, linear, exponential
|
|
|
|
throw "message" # Raise error
|
|
```
|
|
|
|
### Conditionals
|
|
|
|
```prose
|
|
if **condition**:
|
|
session "..."
|
|
elif **other condition**:
|
|
session "..."
|
|
else:
|
|
session "..."
|
|
```
|
|
|
|
### Choice
|
|
|
|
```prose
|
|
choice **criteria**:
|
|
option "Label A":
|
|
session "..."
|
|
option "Label B":
|
|
session "..."
|
|
```
|
|
|
|
### Blocks
|
|
|
|
```prose
|
|
block name(param): # Define with parameters
|
|
session "... {param} ..."
|
|
|
|
do name("value") # Invoke with arguments
|
|
```
|
|
|
|
### String Interpolation
|
|
|
|
```prose
|
|
let x = session "Get value"
|
|
session "Use {x} in prompt" # Single-line
|
|
|
|
session """ # Multi-line
|
|
Multi-line prompt with {x}
|
|
"""
|
|
```
|
|
|
|
## Learn More
|
|
|
|
See `compiler.md` in the skill directory for the complete language specification.
|