loudmouth-ai 0.1.0 → 0.2.0

package/extensions/open-prose/skills/prose/lib/program-improver.prose

@@ -1,275 +0,0 @@
-# Program Improver
-# Analyzes inspection reports and proposes improvements to .prose source code
-#
-# Usage:
-#   prose run @openprose/lib/program-improver
-#
-# Inputs:
-#   inspection_path: Path to inspection binding
-#   run_path: Path to the inspected run (to find program.prose)
-#
-# Output: PR to source repo if accessible, otherwise proposal file
-
-input inspection_path: "Path to inspection output (bindings/inspection.md)"
-input run_path: "Path to the inspected run directory"
-
-# ============================================================
-# Agents
-# ============================================================
-
-agent locator:
-  model: sonnet
-  prompt: """
-    You find the source location of .prose programs.
-
-    Check:
-    - Registry reference in program header (e.g., @handle/slug)
-    - Local file paths
-    - Whether source repo is accessible for PRs
-  """
-
-agent analyst:
-  model: opus
-  prompt: """
-    You analyze OpenProse inspection reports for program improvement opportunities.
-
-    Look for:
-    - Wrong model tier (using opus where sonnet suffices, or vice versa)
-    - Missing error handling (no try/catch around risky operations)
-    - Suboptimal control flow (sequential where parallel would work)
-    - Context passing issues (passing too much, or missing context)
-    - Unnecessary complexity (over-engineered for the task)
-    - Missing parallelization (independent operations run sequentially)
-    - Agent prompt issues (vague, missing constraints, wrong role)
-
-    Be specific. Quote evidence from inspection.
-  """
-
-agent implementer:
-  model: opus
-  prompt: """
-    You improve .prose programs while preserving their intent.
-
-    Rules:
-    - Keep the same overall structure
-    - Make minimal, targeted changes
-    - Follow OpenProse idioms
-    - Preserve comments and documentation
-    - One logical improvement per change
-  """
-
-agent pr_author:
-  model: sonnet
-  prompt: """
-    You create branches and pull requests or write proposal files.
-  """
-
-# ============================================================
-# Phase 1: Locate Program Source
-# ============================================================
-
-let source_info = session: locator
-  prompt: """
-    Find the source of the inspected program.
-
-    Run path: {run_path}
-
-    Steps:
-    1. Read {run_path}/program.prose
-    2. Check header for registry reference (e.g., # from: @handle/slug)
-    3. Check if it's a lib/ program (part of OpenProse)
-    4. Determine if we can create a PR
-
-    Return JSON:
-    {
-      "program_name": "name from header or filename",
-      "registry_ref": "@handle/slug or null",
-      "source_type": "lib" | "local" | "registry" | "unknown",
-      "source_path": "path to original source or null",
-      "source_repo": "git repo URL or null",
-      "can_pr": true/false,
-      "program_content": "full program source"
-    }
-  """
-  context: run_path
-
-# ============================================================
-# Phase 2: Analyze for Improvements
-# ============================================================
-
-let analysis = session: analyst
-  prompt: """
-    Analyze this program and its inspection for improvement opportunities.
-
-    Program source:
-    {source_info.program_content}
-
-    Inspection report: {inspection_path}
-
-    For each opportunity:
-    - category: model-tier | error-handling | flow | context | complexity | parallel | prompts
-    - description: what could be better
-    - severity: low | medium | high
-    - location: which part of program (agent name, phase, line range)
-    - evidence: what in the inspection suggests this
-    - proposed_fix: brief description of the change
-
-    Return JSON:
-    {
-      "program_name": "{source_info.program_name}",
-      "opportunities": [...],
-      "priority_order": [indices by impact]
-    }
-  """
-  context: { source_info, inspection_path }
-
-if **no actionable opportunities found**:
-  output result = {
-    status: "no-improvements-needed",
-    source_info: source_info,
-    analysis: analysis,
-    message: "Program executed well, no obvious improvements"
-  }
-
-# ============================================================
-# Phase 3: User Selection
-# ============================================================
-
-input selection: """
-  ## Program Improvement Opportunities
-
-  Program: {source_info.program_name}
-  Source: {source_info.source_type} ({source_info.source_path})
-  Can PR: {source_info.can_pr}
-
-  ### Opportunities Found:
-  {analysis.opportunities}
-
-  ---
-
-  Which improvements should I implement?
-  - List by number
-  - Or "all" for everything
-  - Or "none" to skip
-"""
-
-if **user selected none or wants to skip**:
-  output result = {
-    status: "skipped",
-    source_info: source_info,
-    analysis: analysis
-  }
-
-let selected = session "Parse selection"
-  prompt: "Extract selected opportunity indices"
-  context: { selection, analysis }
-
-# ============================================================
-# Phase 4: Implement Changes
-# ============================================================
-
-let implementation = session: implementer
-  prompt: """
-    Implement the selected improvements to this program.
-
-    Original program:
-    {source_info.program_content}
-
-    Selected opportunities: {selected}
-    Full analysis: {analysis}
-
-    Write the improved program. Make all selected changes.
-
-    Return JSON:
-    {
-      "improved_program": "full .prose source with improvements",
-      "changes_made": [
-        {
-          "opportunity_index": N,
-          "description": "what was changed",
-          "lines_affected": "before/after summary"
-        }
-      ],
-      "branch_name": "program/{program_name}-improvements"
-    }
-  """
-  context: { source_info, selected, analysis }
-
-# ============================================================
-# Phase 5: Create PR or Proposal
-# ============================================================
-
-if **source_info.can_pr is true**:
-  let pr = session: pr_author
-    prompt: """
-      Create a PR for this program improvement.
-
-      Source path: {source_info.source_path}
-      Source repo: {source_info.source_repo}
-      Branch: {implementation.branch_name}
-      Changes: {implementation.changes_made}
-      Improved program: {implementation.improved_program}
-
-      Steps:
-      1. cd to repo containing source
-      2. Create branch
-      3. Write improved program to source path
-      4. Commit with clear message
-      5. Push and create PR
-
-      PR body should explain each improvement.
-
-      Return: { pr_url, branch, title }
-    """
-    context: { source_info, implementation }
-    permissions:
-      bash: allow
-      write: ["**/*.prose"]
-
-  output result = {
-    status: "pr-created",
-    source_info: source_info,
-    analysis: analysis,
-    implementation: implementation,
-    pr: pr
-  }
-
-else:
-  # Write proposal file since we can't PR
-  let proposal_path = session: pr_author
-    prompt: """
-      Write a proposal file for this improvement.
-
-      Since we can't create a PR directly, write a proposal to:
-      .prose/proposals/{source_info.program_name}-improvements.md
-
-      Include:
-      # Improvement Proposal: {source_info.program_name}
-
-      ## Original Source
-      {source_info.source_path or source_info.registry_ref}
-
-      ## Changes Proposed
-      {implementation.changes_made}
-
-      ## Improved Program
-      ```prose
-      {implementation.improved_program}
-      ```
-
-      ## How to Apply
-      Instructions for manually applying or submitting upstream.
-
-      Return: { proposal_path }
-    """
-    context: { source_info, implementation }
-    permissions:
-      write: [".prose/proposals/*.md"]
-
-  output result = {
-    status: "proposal-written",
-    source_info: source_info,
-    analysis: analysis,
-    implementation: implementation,
-    proposal: proposal_path
-  }

package/extensions/open-prose/skills/prose/lib/project-memory.prose

@@ -1,118 +0,0 @@
-# Project Memory
-# A persistent agent that understands this specific project
-#
-# Usage:
-#   prose run @openprose/lib/project-memory --backend sqlite+
-#
-# Recommended backend: sqlite+ (for durable project-scoped persistence)
-#
-# Modes:
-#   ingest: Read and understand content (code, docs, history)
-#   query: Ask questions about the project
-#   update: Record decisions, changes, or learnings
-#   summarize: Get an overview of the project
-#
-# The memory agent builds understanding over time. Ingest key files,
-# record decisions as you make them, and query when you need context.
-
-input mode: "Mode: ingest | query | update | summarize"
-input content: "Content to ingest, question to ask, update to record, or topic to summarize"
-
-# ============================================================
-# Agent
-# ============================================================
-
-agent memory:
-  model: opus
-  persist: project
-  prompt: """
-    You are this project's institutional memory.
-
-    You know:
-    - Architecture and design decisions (and WHY they were made)
-    - Key files, modules, and their purposes
-    - Patterns and conventions used in this codebase
-    - History of major changes and refactors
-    - Known issues, tech debt, and workarounds
-    - Dependencies and their purposes
-    - Configuration and environment setup
-    - Team decisions and their rationale
-
-    Principles:
-    - Remember the WHY, not just the WHAT.
-    - Track evolution—how things changed over time.
-    - Note uncertainty and gaps in your knowledge.
-    - Reference specific files, commits, or discussions when possible.
-    - Keep knowledge structured and retrievable.
-  """
-
-# ============================================================
-# Modes
-# ============================================================
-
-if **mode is ingest**:
-  output result = resume: memory
-    prompt: """
-      Ingest and understand this content:
-
-      {content}
-
-      This might be code, documentation, git history, PR discussions,
-      architecture diagrams, or any other project artifact.
-
-      Extract the important information and integrate it into your
-      understanding of this project. Note:
-      - What this tells you about the project
-      - How it connects to what you already know
-      - Any new patterns or conventions you observe
-    """
-
-elif **mode is query**:
-  output result = resume: memory
-    prompt: """
-      Question: {content}
-
-      Answer from your knowledge of this project.
-
-      When relevant:
-      - Reference specific files or modules
-      - Cite decisions or discussions you remember
-      - Note historical context
-      - Flag if you're uncertain or making inferences
-    """
-
-elif **mode is update**:
-  output result = resume: memory
-    prompt: """
-      Record this update:
-
-      {content}
-
-      This might be:
-      - A new architectural decision
-      - A change in direction or approach
-      - A lesson learned from debugging
-      - New context about requirements
-      - Tech debt being added or resolved
-
-      Integrate this into your project knowledge. Note the date
-      and how this relates to previous understanding.
-    """
-
-elif **mode is summarize**:
-  output result = resume: memory
-    prompt: """
-      Summarize your knowledge about: {content}
-
-      If this is a broad topic (or empty), give a project overview.
-      If specific, focus on that area.
-
-      Include:
-      - Current state of understanding
-      - Key decisions and their rationale
-      - Known issues or gaps
-      - Recent changes if relevant
-    """
-
-else:
-  throw "Unknown mode: {mode}. Use: ingest, query, update, or summarize"

package/extensions/open-prose/skills/prose/lib/user-memory.prose

@@ -1,93 +0,0 @@
-# User Memory
-# A persistent agent that learns and remembers across all your projects
-#
-# Usage:
-#   prose run @openprose/lib/user-memory --backend sqlite+
-#
-# Recommended backend: sqlite+ (for durable cross-project persistence)
-#
-# Modes:
-#   teach: Add new knowledge
-#   query: Ask questions
-#   reflect: Summarize what you know about a topic
-#
-# The memory agent accumulates knowledge over time. Each interaction
-# builds on previous ones. Use liberally—teach it your preferences,
-# decisions, patterns, and lessons learned.
-
-input mode: "Mode: teach | query | reflect"
-input content: "What to teach, ask, or reflect on"
-
-# ============================================================
-# Agent
-# ============================================================
-
-agent memory:
-  model: opus
-  persist: user
-  prompt: """
-    You are the user's personal knowledge base, persisting across all projects.
-
-    You remember:
-    - Technical preferences (languages, frameworks, patterns they prefer)
-    - Architectural decisions and their reasoning
-    - Coding conventions and style preferences
-    - Mistakes they've learned from (and what to do instead)
-    - Domain knowledge they've accumulated
-    - Project contexts and how they relate
-    - Tools, libraries, and configurations they use
-    - Opinions and strong preferences
-
-    Principles:
-    - Be concise. Store knowledge efficiently.
-    - Prioritize actionable knowledge over trivia.
-    - Note confidence levels when uncertain.
-    - Update previous knowledge when new info contradicts it.
-    - Connect related pieces of knowledge.
-  """
-
-# ============================================================
-# Modes
-# ============================================================
-
-if **mode is teach**:
-  output result = resume: memory
-    prompt: """
-      Learn and remember this:
-
-      {content}
-
-      Integrate with your existing knowledge. If this updates or
-      contradicts something you knew before, note the change.
-
-      Respond with a brief confirmation of what you learned.
-    """
-
-elif **mode is query**:
-  output result = resume: memory
-    prompt: """
-      Question: {content}
-
-      Answer from your accumulated knowledge about this user.
-
-      If you know relevant context, share it.
-      If you're uncertain, say so.
-      If you don't know, say that clearly.
-    """
-
-elif **mode is reflect**:
-  output result = resume: memory
-    prompt: """
-      Reflect on your knowledge about: {content}
-
-      Summarize:
-      - What you know about this topic
-      - How confident you are
-      - Gaps in your knowledge
-      - What would be valuable to learn
-
-      Be honest about the limits of what you know.
-    """
-
-else:
-  throw "Unknown mode: {mode}. Use: teach, query, or reflect"