@pennyfarthing/core 9.2.0 → 9.3.0

package/pennyfarthing-dist/workflows/project-context/steps/step-03-complete.md

@@ -1,306 +0,0 @@
-# Step 3: Context Completion & Finalization
-
-<purpose>
-Complete the project context file, optimize it for LLM efficiency, validate all critical rules are captured and actionable, and provide guidance for usage and maintenance.
-</purpose>
-
-<instructions>
-1. Review complete context file for content and structure analysis
-2. Optimize content for LLM context efficiency
-3. Remove redundant or obvious information
-4. Ensure final structure follows optimized format
-5. Present completion summary to user based on skill level
-6. Update frontmatter with completion status
-7. Add usage guidelines section for agents and humans
-8. Validate all critical rules are complete
-9. Provide clear next steps for agent integration and maintenance
-</instructions>
-
-<output>
-- Complete context file reviewed and optimized
-- Content optimized for LLM efficiency
-- Final structure validated
-- Completion summary presented to user
-- Frontmatter updated with status: 'complete'
-- Usage guidelines section appended
-- Validation checklist completed
-- File ready for AI agent consumption
-- Next steps provided for maintenance and evolution
-</output>
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-- 🛑 NEVER generate content without user input
-- ✅ ALWAYS treat this as collaborative completion between technical peers
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- 💬 FOCUS on finalizing a lean, LLM-optimized project context
-- 🎯 ENSURE all critical rules are captured and actionable
-- ⚠️ ABSOLUTELY NO TIME ESTIMATES - AI development speed has fundamentally changed
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Show your analysis before taking any action
-- 📝 Review and optimize content for LLM context efficiency
-- 📖 Update frontmatter with completion status
-- 🚫 NO MORE STEPS - this is the final step
-
-## CONTEXT BOUNDARIES:
-
-- All rule categories from step-2 are complete
-- Technology stack and versions are documented
-- Focus on final review, optimization, and completion
-- Ensure the context file is ready for AI agent consumption
-
-## YOUR TASK:
-
-Complete the project context file, optimize it for LLM efficiency, and provide guidance for usage and maintenance.
-
-## COMPLETION SEQUENCE:
-
-### 1. Review Complete Context File
-
-Read the entire project context file and analyze:
-
-**Content Analysis:**
-
-- Total length and readability for LLMs
-- Clarity and specificity of rules
-- Coverage of all critical areas
-- Actionability of each rule
-
-**Structure Analysis:**
-
-- Logical organization of sections
-- Consistency of formatting
-- Absence of redundant or obvious information
-- Optimization for quick scanning
-
-### 2. Optimize for LLM Context
-
-Ensure the file is lean and efficient:
-
-**Content Optimization:**
-
-- Remove any redundant rules or obvious information
-- Combine related rules into concise bullet points
-- Use specific, actionable language
-- Ensure each rule provides unique value
-
-**Formatting Optimization:**
-
-- Use consistent markdown formatting
-- Implement clear section hierarchy
-- Ensure scannability with strategic use of bolding
-- Maintain readability while maximizing information density
-
-### 3. Final Content Structure
-
-Ensure the final structure follows this optimized format:
-
-```markdown
-# Project Context for AI Agents
-
-_This file contains critical rules and patterns that AI agents must follow when implementing code in this project. Focus on unobvious details that agents might otherwise miss._
-
----
-
-## Technology Stack & Versions
-
-{{concise_technology_list}}
-
-## Critical Implementation Rules
-
-### Language-Specific Rules
-
-{{specific_language_rules}}
-
-### Framework-Specific Rules
-
-{{framework_patterns}}
-
-### Testing Rules
-
-{{testing_requirements}}
-
-### Code Quality & Style Rules
-
-{{style_and_quality_patterns}}
-
-### Development Workflow Rules
-
-{{workflow_patterns}}
-
-### Critical Don't-Miss Rules
-
-{{anti_patterns_and_edge_cases}}
-
----
-
-## Usage Guidelines
-
-**For AI Agents:**
-
-- Read this file before implementing any code
-- Follow ALL rules exactly as documented
-- When in doubt, prefer the more restrictive option
-- Update this file if new patterns emerge
-
-**For Humans:**
-
-- Keep this file lean and focused on agent needs
-- Update when technology stack changes
-- Review quarterly for outdated rules
-- Remove rules that become obvious over time
-
-Last Updated: {{date}}
-```
-
-### 4. Present Completion Summary
-
-Based on user skill level, present the completion:
-
-**Expert Mode:**
-"Project context complete. Optimized for LLM consumption with {{rule_count}} critical rules across {{section_count}} sections.
-
-File saved to: `{output_folder}/project-context.md`
-
-Ready for AI agent integration."
-
-**Intermediate Mode:**
-"Your project context is complete and optimized for AI agents!
-
-**What we created:**
-
-- {{rule_count}} critical implementation rules
-- Technology stack with exact versions
-- Framework-specific patterns and conventions
-- Testing and quality guidelines
-- Workflow and anti-pattern rules
-
-**Key benefits:**
-
-- AI agents will implement consistently with your standards
-- Reduced context switching and implementation errors
-- Clear guidance for unobvious project requirements
-
-**Next steps:**
-
-- AI agents should read this file before implementing
-- Update as your project evolves
-- Review periodically for optimization"
-
-**Beginner Mode:**
-"Excellent! Your project context guide is ready! 🎉
-
-**What this does:**
-Think of this as a 'rules of the road' guide for AI agents working on your project. It ensures they all follow the same patterns and avoid common mistakes.
-
-**What's included:**
-
-- Exact technology versions to use
-- Critical coding rules they might miss
-- Testing and quality standards
-- Workflow patterns to follow
-
-**How AI agents use it:**
-They read this file before writing any code, ensuring everything they create follows your project's standards perfectly.
-
-Your project context is saved and ready to help agents implement consistently!"
-
-### 5. Final File Updates
-
-Update the project context file with completion information:
-
-**Frontmatter Update:**
-
-```yaml
----
-project_name: '{{project_name}}'
-user_name: '{{user_name}}'
-date: '{{date}}'
-sections_completed:
-  ['technology_stack', 'language_rules', 'framework_rules', 'testing_rules', 'quality_rules', 'workflow_rules', 'anti_patterns']
-status: 'complete'
-rule_count: { { total_rules } }
-optimized_for_llm: true
----
-```
-
-**Add Usage Section:**
-Append the usage guidelines from step 3 to complete the document.
-
-### 6. Completion Validation
-
-Final checks before completion:
-
-**Content Validation:**
-✅ All critical technology versions documented
-✅ Language-specific rules are specific and actionable
-✅ Framework rules cover project conventions
-✅ Testing rules ensure consistency
-✅ Code quality rules maintain standards
-✅ Workflow rules prevent conflicts
-✅ Anti-pattern rules prevent common mistakes
-
-**Format Validation:**
-✅ Content is lean and optimized for LLMs
-✅ Structure is logical and scannable
-✅ No redundant or obvious information
-✅ Consistent formatting throughout
-
-### 7. Completion Message
-
-Present final completion to user:
-
-"✅ **Project Context Generation Complete!**
-
-Your optimized project context file is ready at:
-`{output_folder}/project-context.md`
-
-**📊 Context Summary:**
-
-- {{rule_count}} critical rules for AI agents
-- {{section_count}} comprehensive sections
-- Optimized for LLM context efficiency
-- Ready for immediate agent integration
-
-**🎯 Key Benefits:**
-
-- Consistent implementation across all AI agents
-- Reduced common mistakes and edge cases
-- Clear guidance for project-specific patterns
-- Minimal LLM context usage
-
-**📋 Next Steps:**
-
-1. AI agents will automatically read this file when implementing
-2. Update this file when your technology stack or patterns evolve
-3. Review quarterly to optimize and remove outdated rules
-
-Your project context will help ensure high-quality, consistent implementation across all development work. Great work capturing your project's critical implementation requirements!"
-
-## SUCCESS METRICS:
-
-✅ Complete project context file with all critical rules
-✅ Content optimized for LLM context efficiency
-✅ All technology versions and patterns documented
-✅ File structure is logical and scannable
-✅ Usage guidelines included for agents and humans
-✅ Frontmatter properly updated with completion status
-✅ User provided with clear next steps and benefits
-
-## FAILURE MODES:
-
-❌ Final content is too verbose for LLM consumption
-❌ Missing critical implementation rules or patterns
-❌ Not optimizing content for agent readability
-❌ Not providing clear usage guidelines
-❌ Frontmatter not properly updated
-❌ Not validating file completion before ending
-
-## WORKFLOW COMPLETE:
-
-This is the final step of the Generate Project Context workflow. The user now has a comprehensive, optimized project context file that will ensure consistent, high-quality implementation across all AI agents working on the project.
-
-The project context file serves as the critical "rules of the road" that agents need to implement code consistently with the project's standards and patterns.

package/pennyfarthing-dist/workflows/project-context/workflow.yaml

@@ -1,27 +0,0 @@
-# generate-project-context Workflow - Migrated from BMAD format
-# Generated by migrate-bmad-workflow.mjs
-
-workflow:
-  name: generate-project-context
-  description: Creates a concise project-context.md file with critical rules and patterns that AI agents must follow when implementing code. Optimized for LLM context efficiency.
-  version: "1.0.0"
-  type: stepped
-
-  # Step configuration
-  steps:
-    path: ./steps/
-    pattern: step-*.md
-
-  # Variables available in step files
-  variables:
-    project_root: .
-    planning_artifacts: ./artifacts
-    output_file: artifacts/generate-project-context.md
-
-  # Agent assignment (customize as needed)
-  agent: architect
-
-  # Triggers - when to suggest this workflow
-  triggers:
-    types: [generate-project-context]
-    tags: [generate-project-context, stepped]

package/pennyfarthing-dist/workflows/project-setup/steps/step-01-discover.md

@@ -1,157 +0,0 @@
-# Step 1: Project Discovery
-
-<purpose>
-Discover the project structure, detect repositories, identify tech stack, and gather information needed to configure Pennyfarthing.
-</purpose>
-
-<instructions>
-1. Scan project root for repository structure
-2. Detect package managers and languages
-3. Identify monorepo vs single-repo structure
-4. Find test/build/lint commands
-5. Present discovery summary for user confirmation
-</instructions>
-
-<output>
-- Project structure map
-- Detected repositories with paths
-- Tech stack (languages, frameworks, package managers)
-- Extracted commands (test, build, lint)
-- User-confirmed discovery ready for repos.yaml generation
-</output>
-
-## DISCOVERY TASKS
-
-### 1. Detect Repository Structure
-
-Scan for git repositories and orchestrator patterns:
-
-```bash
-# Find all .git directories (indicates repos)
-find . -name ".git" -type d -maxdepth 3 2>/dev/null
-
-# Check if this is a monorepo
-ls -la pnpm-workspace.yaml lerna.json turborepo.json package.json 2>/dev/null
-
-# Check for orchestrator pattern (sprint/, .session/ directories)
-ls -la sprint/ .session/ 2>/dev/null
-
-# Check .gitignore for ignored subrepo patterns
-grep -E "^[a-zA-Z].*-api/?$|^[a-zA-Z].*-ui/?$|^[a-zA-Z]+/$" .gitignore 2>/dev/null
-```
-
-**Classify structure:**
-- **Single repo**: Only `./.git` exists, no sprint/
-- **Monorepo**: Workspace config found (pnpm-workspace.yaml, lerna.json, etc.)
-- **Orchestrator**: Has sprint/ and/or multiple `.git` directories (subrepos)
-
-### 1a. Detect Orchestrator Pattern (Critical)
-
-The orchestrator pattern uses gitignored subrepos:
-
-```
-my-project/                    # Orchestrator (git repo)
-├── .gitignore                 # Contains: my-project-api/, my-project-ui/
-├── sprint/                    # Sprint tracking (key indicator)
-├── .session/                  # Work sessions
-├── my-project-api/            # Subrepo (separate git, gitignored)
-│   └── .git/
-└── my-project-ui/             # Subrepo (separate git, gitignored)
-    └── .git/
-```
-
-**Detection steps:**
-1. Check for `sprint/` directory → indicates orchestrator
-2. Parse `.gitignore` for directory patterns (ending in `/`)
-3. Check if those directories exist AND have their own `.git`
-4. These are subrepos, not just ignored directories
-
-**Example .gitignore patterns to look for:**
-```gitignore
-# Subrepos (cloned separately)
-conductor-api/
-conductor-ui/
-
-# OR with wildcards
-*-api/
-*-ui/
-```
-
-**Important:** Subrepos may not exist yet (not cloned). The .gitignore tells us what SHOULD be there.
-
-### 2. Detect Tech Stack
-
-For each repository/directory, check for:
-
-| File | Indicates | Extract |
-|------|-----------|---------|
-| `package.json` | Node.js/JavaScript/TypeScript | name, scripts, dependencies |
-| `Cargo.toml` | Rust | name, version |
-| `pyproject.toml` / `requirements.txt` | Python | name, dependencies |
-| `go.mod` | Go | module name |
-| `pom.xml` / `build.gradle` | Java | project info |
-| `tsconfig.json` | TypeScript | compiler options |
-
-### 3. Extract Commands
-
-From `package.json` scripts or equivalent:
-
-```yaml
-test_command: npm test | pnpm test | cargo test | pytest
-build_command: npm run build | cargo build | python setup.py build
-lint_command: npm run lint | cargo clippy | ruff check
-dev_command: npm run dev | cargo watch
-```
-
-### 4. Identify Project Type
-
-Based on discovery, classify:
-
-| Type | Indicators |
-|------|------------|
-| `api` | Express, FastAPI, Gin, Actix endpoints |
-| `ui` | React, Vue, Svelte, frontend frameworks |
-| `cli` | bin entry in package.json, main.rs with clap |
-| `library` | exports, no bin entry |
-| `orchestrator` | sprint/, .session/, multiple subrepos |
-| `framework` | distributable content, templates |
-
-### 5. Present Discovery Summary
-
-```
-📁 Project Discovery Summary
-════════════════════════════
-
-Project Name: {detected_name}
-Structure: {single|monorepo|orchestrator}
-
-Repositories Found:
-┌────────────────┬──────────┬────────────┬─────────────────┐
-│ Path           │ Type     │ Language   │ Framework       │
-├────────────────┼──────────┼────────────┼─────────────────┤
-│ .              │ {type}   │ {lang}     │ {framework}     │
-│ packages/api   │ api      │ TypeScript │ Express         │
-│ packages/ui    │ ui       │ TypeScript │ React           │
-└────────────────┴──────────┴────────────┴─────────────────┘
-
-Detected Commands:
-  test:  {test_command}
-  build: {build_command}
-  lint:  {lint_command}
-
-[C] Confirm and continue to repos.yaml generation
-[E] Edit - let me provide corrections
-[R] Rescan with different parameters
-```
-
-## SUCCESS CRITERIA
-
-✅ All git repositories detected
-✅ Tech stack accurately identified
-✅ Commands extracted from package files
-✅ Project type classified
-✅ User confirms discovery is accurate
-
-## NEXT STEP
-
-After user confirms with [C], proceed to `step-02-clone-repos.md` to optionally clone subrepos and set up the orchestrator pattern.

package/pennyfarthing-dist/workflows/project-setup/steps/step-02-clone-repos.md

@@ -1,217 +0,0 @@
-# Step 2: Clone Subrepos (Optional)
-
-<purpose>
-Allow users to clone subrepos to set up or complete an orchestrator pattern. This step enables real-time repo cloning during project setup.
-</purpose>
-
-<instructions>
-1. Analyze discovery results for missing subrepos
-2. Check .gitignore for expected but missing repos
-3. Offer to clone missing repos or add new ones
-4. Update .gitignore with new repo patterns
-5. Re-scan after cloning to update discovery
-</instructions>
-
-<output>
-- Subrepos cloned as needed
-- .gitignore updated with new patterns
-- Discovery data refreshed with new repos
-- User ready to proceed to repos.yaml generation
-</output>
-
-## ORCHESTRATOR PATTERN SETUP
-
-### Detecting Missing Subrepos
-
-From step 1, we may have found:
-- Patterns in .gitignore that don't have corresponding directories
-- A sprint/ directory but no subrepos
-- An incomplete orchestrator setup
-
-```
-⚠️  Orchestrator Pattern Detected - Missing Subrepos
-
-Expected (from .gitignore):
-  ❌ conductor-api/     (not found)
-  ❌ conductor-ui/      (not found)
-
-Found:
-  ✓ sprint/            (orchestrator confirmed)
-  ✓ .pennyfarthing/    (framework installed)
-```
-
-### Clone Options Menu
-
-```
-📦 Subrepo Setup
-════════════════
-
-This appears to be an orchestrator project. Would you like to:
-
-[C] Clone missing subrepos
-    - conductor-api from git@github.com:org/conductor-api.git
-    - conductor-ui from git@github.com:org/conductor-ui.git
-
-[A] Add a new subrepo
-    - Enter repo URL to clone
-
-[S] Skip - configure repos.yaml with placeholders
-
-[N] Not an orchestrator - this is a standalone project
-```
-
-### Clone Workflow
-
-If user selects [C] or [A]:
-
-#### 1. Gather Repository Information
-
-```
-🔗 Clone Subrepo
-════════════════
-
-Repository URL: {user enters URL}
-  Example: git@github.com:org/project-api.git
-  Example: https://github.com/org/project-ui.git
-
-Local directory name: {auto-detect or user enters}
-  Suggested: {project}-api (from URL)
-
-Branch to clone: {default: main or develop}
-  [Enter] for default, or specify branch
-```
-
-#### 2. Execute Clone
-
-```bash
-# Clone the repository
-git clone {url} {directory_name}
-
-# Optionally checkout specific branch
-cd {directory_name} && git checkout {branch}
-```
-
-#### 3. Update .gitignore
-
-After successful clone, offer to update .gitignore:
-
-```
-✓ Cloned {repo_name} to {directory}/
-
-Add to .gitignore? [Y/n]
-```
-
-If yes, append:
-```gitignore
-# Subrepo - clone separately
-{directory_name}/
-```
-
-#### 4. Detect Repo Type
-
-After cloning, analyze the new repo:
-
-```
-📊 Analyzing {directory_name}...
-
-Detected:
-  Type: api
-  Language: TypeScript
-  Framework: Express
-  Test command: npm test
-  Build command: npm run build
-
-Is this correct? [Y/n/e]
-```
-
-### Setting Up New Orchestrator
-
-If no orchestrator pattern exists but user wants one:
-
-```
-🏗️  Create Orchestrator Pattern
-═══════════════════════════════
-
-This will set up your project as an orchestrator:
-
-1. Create sprint/ directory structure
-2. Create .session/ for work tracking
-3. Add Pennyfarthing workflow support
-
-Subrepos to include:
-  [ ] Add API repo
-  [ ] Add UI repo
-  [ ] Add other repo
-
-[P] Proceed with orchestrator setup
-[S] Skip - keep as single repo
-```
-
-### Common Orchestrator Patterns
-
-Offer templates based on project type:
-
-```
-📋 Orchestrator Templates
-═════════════════════════
-
-[1] API + UI (most common)
-    - {project}-api/ (backend)
-    - {project}-ui/ (frontend)
-
-[2] API + UI + Shared (monorepo-like)
-    - {project}-api/
-    - {project}-ui/
-    - {project}-shared/
-
-[3] Microservices
-    - {project}-gateway/
-    - {project}-service-a/
-    - {project}-service-b/
-
-[4] Custom - define your own repos
-```
-
-## RE-SCAN AFTER CHANGES
-
-After any cloning or setup:
-
-```bash
-# Re-run discovery
-find . -name ".git" -type d -maxdepth 3
-
-# Update tech stack detection
-# (runs same detection as step 1)
-```
-
-Present updated discovery:
-
-```
-📁 Updated Project Structure
-════════════════════════════
-
-Repositories:
-┌────────────────┬──────────┬────────────┐
-│ Path           │ Type     │ Status     │
-├────────────────┼──────────┼────────────┤
-│ .              │ orch     │ existing   │
-│ conductor-api/ │ api      │ ✓ cloned   │
-│ conductor-ui/  │ ui       │ ✓ cloned   │
-└────────────────┴──────────┴────────────┘
-
-[C] Continue to repos.yaml generation
-[A] Add another repo
-[R] Remove a repo from tracking
-```
-
-## SUCCESS CRITERIA
-
-✅ All desired subrepos cloned
-✅ .gitignore properly updated
-✅ Discovery data refreshed
-✅ Repo types correctly identified
-✅ User ready to proceed
-
-## NEXT STEP
-
-After repos are cloned and discovery is refreshed, proceed to `step-03-repos-yaml.md` to generate the repos.yaml configuration.