loudmouth-ai 0.1.0 → 0.2.0

package/extensions/open-prose/skills/prose/examples/48-habit-miner.prose

@@ -1,445 +0,0 @@
-# Habit Miner
-# Excavates your AI session history to find recurring workflows worth automating
-# Scans .claude, .opencode, .cursor, etc. — discovers patterns, writes .prose programs
-#
-# BACKEND: Run with sqlite+ or postgres for incremental processing across runs
-#   prose run 48-habit-miner.prose --backend sqlite+
-#
-# KEY VM FEATURES USED:
-# - persist: true on miner — remembers patterns across runs, watches them mature
-# - resume: — incremental processing, only analyzes new logs since last run
-# - recursive blocks — handles arbitrarily large log corpora
-# - reference-based context — agents read from storage, not everything in memory
-
-input mode: "Mode: 'full' (analyze everything), 'incremental' (new logs only), 'check' (see what's new)"
-input min_frequency: "Minimum times a pattern must appear to qualify (default: 3)"
-input focus: "Optional: filter to specific area (e.g., 'git', 'testing', 'refactoring')"
-
-# ============================================================
-# Agents
-# ============================================================
-
-agent scout:
-  model: sonnet
-  prompt: """
-    You discover AI assistant log files on the user's system.
-
-    Check common locations:
-    - ~/.claude/ (Claude Code)
-    - ~/.opencode/ (OpenCode)
-    - ~/.cursor/ (Cursor)
-    - ~/.continue/ (Continue)
-    - ~/.aider/ (Aider)
-    - ~/.copilot/ (GitHub Copilot)
-    - ~/.codeium/ (Codeium)
-    - ~/.tabnine/ (Tabnine)
-    - ~/.config/claude-code/
-    - ~/.config/github-copilot/
-    - ~/.local/share/*/
-
-    For each location found, report:
-    - Path
-    - Log format (jsonl, sqlite, json, etc.)
-    - Approximate size
-    - Number of sessions/files
-    - Date range (oldest to newest)
-    - NEW since last scan (if incremental)
-
-    Be thorough but respect permissions. Don't read content yet, just inventory.
-  """
-  permissions:
-    bash: allow
-    read: ["~/.claude/**", "~/.opencode/**", "~/.cursor/**", "~/.continue/**",
-           "~/.aider/**", "~/.copilot/**", "~/.codeium/**", "~/.tabnine/**",
-           "~/.config/**", "~/.local/share/**"]
-
-agent parser:
-  model: sonnet
-  prompt: """
-    You parse AI assistant log files into normalized conversation format.
-
-    Handle formats:
-    - JSONL: one JSON object per line (Claude Code, many others)
-    - SQLite: query conversation tables
-    - JSON: array of messages or nested structure
-    - Markdown: conversation exports
-
-    Extract for each session:
-    - Session ID / timestamp
-    - User messages (the requests)
-    - Assistant actions (tools used, files modified)
-    - Outcome (success/failure indicators)
-
-    Normalize to common schema regardless of source format.
-    Track file modification times for incremental processing.
-  """
-  permissions:
-    bash: allow
-    read: ["~/.claude/**", "~/.opencode/**", "~/.cursor/**", "~/.continue/**",
-           "~/.aider/**", "~/.copilot/**", "~/.codeium/**", "~/.tabnine/**"]
-
-agent miner:
-  model: opus
-  persist: true  # <-- KEY: Remembers patterns across runs
-  prompt: """
-    You find and track patterns in conversation histories over time.
-
-    Your memory contains patterns from previous runs. Each pattern has:
-    - name: descriptive identifier
-    - maturity: emerging (3-5 hits) → established (6-15) → proven (16+)
-    - examples: representative instances
-    - last_seen: when pattern last appeared
-    - trend: growing / stable / declining
-
-    On each run:
-    1. Load your memory of known patterns
-    2. Process new sessions
-    3. Update pattern frequencies and maturity
-    4. Identify NEW emerging patterns
-    5. Note patterns that are declining (not seen recently)
-
-    Patterns MATURE over time. Don't rush to automate emerging patterns.
-    Wait until they're established before recommending automation.
-  """
-
-agent qualifier:
-  model: opus
-  prompt: """
-    You determine which patterns are ready for automation.
-
-    Consider MATURITY (from miner's memory):
-    - emerging: Too early. Note it, but don't automate yet.
-    - established: Good candidate. Enough data to generalize.
-    - proven: Strong candidate. Battle-tested pattern.
-
-    Also consider:
-    - COMPLEXITY: Multi-step, not trivial
-    - CONSISTENCY: Similar enough across instances
-    - AUTOMATABLE: Not too context-dependent
-    - VALUE: Would save meaningful time/effort
-
-    Reject patterns that are:
-    - Still emerging (wait for more data)
-    - Too simple (just run a single command)
-    - Too variable (every instance is different)
-  """
-
-agent author:
-  model: opus
-  prompt: """
-    You write .prose programs from mature workflow patterns.
-
-    For each qualified pattern:
-    - Identify the inputs (what varies between instances)
-    - Identify the constants (what's always the same)
-    - Design appropriate agents for the workflow
-    - Structure phases logically
-    - Add error handling where needed
-    - Include user checkpoints at decision points
-
-    Write idiomatic OpenProse. Follow existing example patterns.
-    Reference the pattern's maturity level in a header comment.
-  """
-  permissions:
-    write: ["**/*.prose"]
-
-agent organizer:
-  model: sonnet
-  prompt: """
-    You organize generated .prose programs into a coherent collection.
-
-    Tasks:
-    - Group related programs by domain (git, testing, docs, etc.)
-    - Suggest directory structure
-    - Create an index/README
-    - Identify programs that could share blocks or agents
-    - Note potential compositions (program A often followed by B)
-  """
-  permissions:
-    write: ["**/*.md", "**/*.prose"]
-
-# ============================================================
-# Recursive block for processing large log corpora
-# ============================================================
-
-block process_logs(sources, depth):
-  # Base case: small enough to process directly
-  if **fewer than 50 sessions** or depth <= 0:
-    output sources | pmap:
-      session: parser
-        prompt: "Parse these logs into normalized format"
-        context: item
-
-  # Recursive case: chunk and fan out
-  let chunks = session "Split sources into ~25 session batches"
-    context: sources
-
-  let results = []
-  parallel for chunk in chunks:
-    let chunk_result = do process_logs(chunk, depth - 1)
-    results = results + chunk_result
-
-  output results
-
-# ============================================================
-# Phase 0: Discovery
-# ============================================================
-
-let inventory = session: scout
-  prompt: """
-    Scan the system for AI assistant log files.
-    Mode: {mode}
-
-    Check all common locations. For each found, report:
-    - Full path
-    - Format detected
-    - Size (human readable)
-    - Session/file count
-    - Date range
-    - If incremental: how many NEW since last scan
-
-    Return a structured inventory.
-  """
-
-# For "check" mode, just show what's available and exit
-if **mode is check**:
-  output result = {
-    status: "check-complete",
-    inventory: inventory,
-    hint: "Run with mode:'incremental' to process new logs, or mode:'full' for everything"
-  }
-
-input source_selection: """
-  ## AI Assistant Logs Found
-
-  {inventory}
-
-  ---
-
-  Mode: {mode}
-
-  Select which sources to analyze:
-  - List the paths you want included
-  - Or say "all" to analyze everything found
-  - Or say "none" to cancel
-"""
-
-if **user selected none or wants to cancel**:
-  output result = {
-    status: "cancelled",
-    inventory: inventory
-  }
-  throw "User cancelled - no sources selected"
-
-let selected_sources = session: scout
-  prompt: "Parse user's selection into a list of paths to analyze"
-  context: { inventory, source_selection, mode }
-
-# ============================================================
-# Phase 1: Parsing (with recursive chunking for scale)
-# ============================================================
-
-let parsed_sessions = do process_logs(selected_sources, 3)
-
-let session_count = session "Count total sessions parsed"
-  context: parsed_sessions
-
-# ============================================================
-# Phase 2: Mining (with persistent memory)
-# ============================================================
-
-# Resume the miner with its accumulated pattern knowledge
-let pattern_update = resume: miner
-  prompt: """
-    Process these new sessions against your pattern memory.
-
-    1. Load your known patterns (with maturity levels)
-    2. Match new sessions to existing patterns OR identify new ones
-    3. Update frequencies, maturity levels, last_seen dates
-    4. Report:
-       - Patterns that MATURED (crossed a threshold)
-       - NEW patterns emerging
-       - Patterns DECLINING (not seen in a while)
-       - Current state of all tracked patterns
-
-    Focus area (if specified): {focus}
-  """
-  context: { parsed_sessions, focus }
-
-# ============================================================
-# Phase 3: Qualification
-# ============================================================
-
-let qualified = session: qualifier
-  prompt: """
-    Review the miner's pattern update. Identify patterns ready for automation.
-
-    Minimum frequency threshold: {min_frequency}
-
-    PRIORITIZE:
-    1. Patterns that just reached "established" or "proven" maturity
-    2. Proven patterns not yet automated
-    3. High-value patterns even if just established
-
-    SKIP:
-    - Emerging patterns (let them mature)
-    - Already-automated patterns (unless significantly evolved)
-    - Declining patterns (might be obsolete)
-
-    Return ranked list with reasoning.
-  """
-  context: { pattern_update, min_frequency }
-
-if **no patterns ready for automation**:
-  output result = {
-    status: "no-new-automations",
-    sessions_analyzed: session_count,
-    pattern_update: pattern_update,
-    message: "Patterns are still maturing. Run again later."
-  }
-
-# ============================================================
-# Phase 4: User Checkpoint
-# ============================================================
-
-input pattern_selection: """
-  ## Patterns Ready for Automation
-
-  Analyzed {session_count} sessions.
-
-  Pattern Update:
-  {pattern_update}
-
-  Ready for automation:
-  {qualified}
-
-  ---
-
-  Which patterns should I write .prose programs for?
-  - List by name or number
-  - Or say "all" for everything qualified
-  - Or say "none" to let patterns mature further
-
-  You can also refine any pattern description before I write code.
-"""
-
-if **user wants to wait for more maturity**:
-  output result = {
-    status: "deferred",
-    sessions_analyzed: session_count,
-    pattern_update: pattern_update,
-    qualified: qualified
-  }
-
-let patterns_to_automate = session: qualifier
-  prompt: "Parse user selection into final list of patterns to automate"
-  context: { qualified, pattern_selection }
-
-# ============================================================
-# Phase 5: Program Generation
-# ============================================================
-
-let programs = patterns_to_automate | map:
-  session: author
-    prompt: """
-      Write a .prose program for this pattern.
-
-      Pattern maturity: {pattern.maturity}
-      Times observed: {pattern.frequency}
-      Representative examples: {pattern.examples}
-
-      The program should:
-      - Parameterize what varies between instances
-      - Hardcode what's always the same
-      - Use appropriate agents for distinct roles
-      - Include error handling
-      - Add user checkpoints at decision points
-
-      Include a header comment noting:
-      - Pattern maturity level
-      - Number of observations it's based on
-      - Date generated
-    """
-    context: item
-
-# ============================================================
-# Phase 6: Organization
-# ============================================================
-
-let organized = session: organizer
-  prompt: """
-    Organize the generated programs.
-
-    Tasks:
-    1. Group by domain (git, testing, docs, refactoring, etc.)
-    2. Suggest directory structure
-    3. Create an index README with:
-       - Program name and one-line description
-       - Pattern maturity (established/proven)
-       - When to use it
-       - Example invocation
-    4. Identify shared patterns that could be extracted
-    5. Note programs that often chain together
-  """
-  context: programs
-
-# ============================================================
-# Phase 7: Output Location
-# ============================================================
-
-input output_location: """
-  ## Generated Programs
-
-  {organized}
-
-  ---
-
-  Where should I write these programs?
-
-  Options:
-  - A directory path (e.g., ~/my-workflows/)
-  - "preview" to just show them without writing
-"""
-
-if **user wants preview only**:
-  output result = {
-    status: "preview",
-    sessions_analyzed: session_count,
-    pattern_update: pattern_update,
-    qualified: qualified,
-    programs: programs,
-    organization: organized
-  }
-
-let written = session: organizer
-  prompt: "Write all programs to the specified location with proper structure"
-  context: { programs, organized, output_location }
-  permissions:
-    write: ["**/*.prose", "**/*.md"]
-
-# ============================================================
-# Output
-# ============================================================
-
-output result = {
-  status: "complete",
-
-  # Discovery
-  sources_scanned: inventory,
-  sources_analyzed: selected_sources,
-
-  # Analysis
-  sessions_analyzed: session_count,
-  pattern_update: pattern_update,
-
-  # Qualification
-  patterns_qualified: qualified,
-  patterns_automated: patterns_to_automate,
-
-  # Generation
-  programs_written: written,
-  organization: organized,
-
-  # For next run
-  next_step: "Run again with mode:'incremental' to process new logs and mature patterns"
-}

package/extensions/open-prose/skills/prose/examples/49-prose-run-retrospective.prose

@@ -1,210 +0,0 @@
-# Prose Run Retrospective
-# Analyzes a completed run to extract learnings and produce an improved version.
-
-input run_id: "Path to the completed run directory"
-input prose_path: "Path to the .prose file that was executed"
-
-const PATTERNS_PATH = "prose/skills/open-prose/guidance/patterns.md"
-const ANTIPATTERNS_PATH = "prose/skills/open-prose/guidance/antipatterns.md"
-
-agent analyst:
-  model: sonnet
-  prompt: """You analyze OpenProse run artifacts to identify issues and classify outcomes.
-Checklist-style evaluation: read systematically, identify issues with evidence, classify outcomes.
-
-Classification criteria:
-- success: Program completed, outputs are correct
-- transient-error: External failure (API timeout, network) - not a program flaw
-- architectural-issue: Structural problem in .prose design
-- antipattern-instance: Program exhibits a known antipattern"""
-
-agent extractor:
-  model: opus
-  prompt: """You extract generalizable patterns from specific experiences.
-Deep reasoning: identify abstract success/failure factors, distinguish situational from generalizable,
-reason about trade-offs, synthesize observations into principles.
-Be conservative - avoid over-generalizing from single instances."""
-
-parallel:
-  run_artifacts = session: analyst
-    prompt: """Read and catalog all artifacts in {run_id}.
-Look for bindings/*.md, state.md, outputs/, error files.
-Summarize what exists and its content."""
-    context:
-      file: "{run_id}/state.md"
-
-  source_analysis = session: analyst
-    prompt: """Parse the .prose file structure at {prose_path}.
-Identify: inputs, agents and models, phase structure, error handling, decision points, outputs."""
-    context:
-      file: prose_path
-
-let classification = session: analyst
-  prompt: """Classify the run outcome.
-
-Run artifacts: {run_artifacts}
-Source structure: {source_analysis}
-
-Determine:
-- outcome_type: success | transient-error | architectural-issue | antipattern-instance
-- confidence: high | medium | low
-- evidence: Specific quotes supporting classification
-- summary: One-line description"""
-
-if **classification indicates transient error (API timeout, network failure) not caused by program**:
-  output result = {
-    status: "transient-error",
-    classification: classification,
-    recommendation: "Re-run the program; no structural changes needed"
-  }
-
-let improvements = session: analyst
-  prompt: """Identify improvement opportunities in the .prose file.
-
-Classification: {classification}
-Source structure: {source_analysis}
-
-For each improvement:
-- What: Specific change
-- Why: Problem it solves
-- Priority: high | medium | low
-
-Focus on structural improvements: model selection, parallelization, error handling, context management."""
-  context:
-    file: PATTERNS_PATH
-    file: ANTIPATTERNS_PATH
-
-let pattern_candidates = session: extractor
-  prompt: """Extract generalizable patterns from this run.
-
-Classification: {classification}
-Improvements: {improvements}
-
-For genuinely novel patterns/antipatterns (not already in guidance):
-- Name (kebab-case)
-- Category
-- Description
-- Example code
-- Rationale
-
-Be conservative. Only propose broadly applicable patterns supported by evidence."""
-  context:
-    file: PATTERNS_PATH
-    file: ANTIPATTERNS_PATH
-
-let improved_prose = session: extractor
-  prompt: """Write an improved version of the .prose file.
-
-Source structure: {source_analysis}
-Improvements: {improvements}
-
-Write the complete improved file:
-- Keep same purpose and inputs
-- Apply identified improvements
-- Follow patterns from guidance
-- Add brief header comment on what changed"""
-  context:
-    file: prose_path
-    file: PATTERNS_PATH
-
-if **pattern_candidates contains no novel patterns worth documenting**:
-  let new_patterns = { count: 0, entries: [] }
-  let new_antipatterns = { count: 0, entries: [] }
-else:
-  parallel:
-    new_patterns = session: analyst
-      prompt: """Draft new pattern entries for patterns.md.
-
-Candidates: {pattern_candidates}
-
-For genuinely novel patterns, follow exact format from patterns.md.
-Output: count, names, and full markdown entries."""
-      context:
-        file: PATTERNS_PATH
-
-    new_antipatterns = session: analyst
-      prompt: """Draft new antipattern entries for antipatterns.md.
-
-Candidates: {pattern_candidates}
-
-For genuinely novel antipatterns, follow exact format from antipatterns.md.
-Output: count, names, and full markdown entries."""
-      context:
-        file: ANTIPATTERNS_PATH
-
-input approval_response: """
-## Retrospective Complete
-
-**Classification**: {classification.outcome_type} ({classification.confidence})
-**Summary**: {classification.summary}
-
-**Improvements**: {improvements}
-
-**New Patterns**: {new_patterns.count} proposed
-**New Antipatterns**: {new_antipatterns.count} proposed
-
-Approve: `all` | `prose-only` | `docs-only` | `none`
-"""
-
-choice **user approval**:
-
-  option "all":
-    session "Write improved prose"
-      prompt: "Write to {run_id}/outputs/improved.prose:\n{improved_prose}"
-      permissions:
-        write: ["{run_id}/outputs/*"]
-
-    if **new_patterns.count > 0**:
-      session "Update patterns.md"
-        prompt: "Append to {PATTERNS_PATH}:\n{new_patterns.entries}"
-        permissions:
-          write: [PATTERNS_PATH]
-
-    if **new_antipatterns.count > 0**:
-      session "Update antipatterns.md"
-        prompt: "Append to {ANTIPATTERNS_PATH}:\n{new_antipatterns.entries}"
-        permissions:
-          write: [ANTIPATTERNS_PATH]
-
-    output result = {
-      status: classification.outcome_type,
-      improved_prose_path: "{run_id}/outputs/improved.prose",
-      patterns_added: new_patterns.names,
-      antipatterns_added: new_antipatterns.names
-    }
-
-  option "prose-only":
-    session "Write improved prose"
-      prompt: "Write to {run_id}/outputs/improved.prose:\n{improved_prose}"
-      permissions:
-        write: ["{run_id}/outputs/*"]
-
-    output result = {
-      status: classification.outcome_type,
-      improved_prose_path: "{run_id}/outputs/improved.prose"
-    }
-
-  option "docs-only":
-    if **new_patterns.count > 0**:
-      session "Update patterns.md"
-        prompt: "Append to {PATTERNS_PATH}:\n{new_patterns.entries}"
-        permissions:
-          write: [PATTERNS_PATH]
-
-    if **new_antipatterns.count > 0**:
-      session "Update antipatterns.md"
-        prompt: "Append to {ANTIPATTERNS_PATH}:\n{new_antipatterns.entries}"
-        permissions:
-          write: [ANTIPATTERNS_PATH]
-
-    output result = {
-      status: classification.outcome_type,
-      patterns_added: new_patterns.names,
-      antipatterns_added: new_antipatterns.names
-    }
-
-  option "none":
-    output result = {
-      status: "review-complete",
-      learnings: pattern_candidates
-    }