From 7a86af0526d260f8496cafb5ed2e7ce9016a8a9c Mon Sep 17 00:00:00 2001 From: Sam Schillace Date: Tue, 23 Sep 2025 13:40:25 -0700 Subject: [PATCH 1/3] feat: add comprehensive instructor website for Amplifier MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Complete documentation website with enhanced content expansion - Interactive examples with copy-paste ready commands - Progressive difficulty levels (Beginner ā†’ Intermediate ā†’ Advanced) - Real-world workflows covering all major scenarios: * Feature development with agent orchestration * Systematic debugging and incident response * Knowledge-driven development patterns * Performance optimization strategies * Parallel development approaches - Platform-specific setup guides with troubleshooting - Detailed agent catalog with practical use cases - Fully responsive design with smooth animations - Working interactive features (tabs, collapsible sections, copy buttons) šŸ¤– Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude --- instructor/agents.html | 1458 +++++++++++++++++++++++++++++++ instructor/examples.html | 1721 +++++++++++++++++++++++++++++++++++++ instructor/index.html | 361 ++++++++ instructor/knowledge.html | 525 +++++++++++ instructor/script.js | 252 ++++++ instructor/setup.html | 1344 +++++++++++++++++++++++++++++ instructor/styles.css | 857 ++++++++++++++++++ 7 files changed, 6518 insertions(+) create mode 100644 instructor/agents.html create mode 100644 instructor/examples.html create mode 100644 instructor/index.html create mode 100644 instructor/knowledge.html create mode 100644 instructor/script.js create mode 100644 instructor/setup.html create mode 100644 instructor/styles.css diff --git a/instructor/agents.html b/instructor/agents.html new file mode 100644 index 00000000..a329aabe --- /dev/null +++ b/instructor/agents.html @@ -0,0 +1,1458 @@ + + + + + + Agent Catalog - Amplifier + + + + + + + +
+ +
+ +
+ +
+
+
+

Specialized AI Agents

+

+ Instead of one generalist AI, Amplifier provides 20+ specialized agents, each expert in specific domains. + Each agent brings focused expertise, proven patterns, and domain-specific knowledge to accelerate your development. +

+
+ + +
+ + + + + +
+ + +
+

šŸ—ļø Core Development

+

+ Agents focused on building, architecting, and maintaining code with best practices and proven patterns. +

+
+
+
+
zen-architect
+ Architecture +
+
+

+ The master architect who embodies ruthless simplicity and Wabi-sabi philosophy. Operates in three powerful modes: + ANALYZE for problem decomposition, ARCHITECT for system design, and REVIEW for code quality assessment. + Creates clear specifications that guide implementation, focusing on essential patterns over unnecessary abstractions. +

+
+

Key Capabilities

+
    +
  • Analysis-first development approach
    • +
  • Modular "bricks & studs" architecture
    • +
  • Clean contract specifications
    • +
  • Complexity elimination strategies
    • +
  • 80/20 principle application
    • +
  • Philosophy compliance review
    • +
+
+ +
+ šŸ“š Practical Examples (click to expand) +
+
+
šŸŽÆ Simple: Design a New Feature
+
+ + 
"Use zen-architect to design a user notification system"
+
+

ā†’ Returns: Problem analysis, 3 solution approaches with trade-offs, modular specification

+
+ +
+
šŸ”§ Intermediate: Architecture Review
+
+ + 
"Have zen-architect review the auth module for complexity and suggest simplifications"
+
+

ā†’ Returns: Complexity score, philosophy alignment, specific refactoring recommendations

+
+ +
+
šŸš€ Advanced: System Redesign
+
+ + 
"zen-architect: Analyze our monolithic app and design a modular migration strategy with clear boundaries"
+
+

ā†’ Returns: Module boundaries, migration phases, contract specifications, dependency graph

+
+
+
+ +
+ šŸ¤ Works Best With +
    +
  • modular-builder: Implements zen-architect's specifications
    • +
  • bug-hunter: Validates architectural decisions work correctly
    • +
  • api-contract-designer: Detailed API design after system architecture
    • +
+
+ +
+ šŸ’” Pro Tips +
    +
  • Always let zen-architect analyze before implementing
    • +
  • Request REVIEW mode for existing code assessment
    • +
  • Use for "stuck" moments - finds simpler paths
    • +
  • Specifications can be regenerated if requirements change
    • +
+
+
+
+ +
+
+
modular-builder
+ Implementation +
+
+

+ The implementation specialist that builds from specifications with precision. Creates self-contained modules with clear boundaries, + automated testing, and regeneration-ready code. Follows the "bricks & studs" philosophy where each module is a complete, replaceable unit. +

+
+

Key Capabilities

+
    +
  • Contract-first implementation
    • +
  • Self-contained module creation
    • +
  • Automated conformance testing
    • +
  • Public/private interface separation
    • +
  • Regeneration-friendly structure
    • +
  • Test-driven development
    • +
+
+ +
+ šŸ“š Practical Examples +
+
+
šŸŽÆ Simple: Build from Spec
+
+ + 
"modular-builder: Implement the user authentication module from zen-architect's spec"
+
+

ā†’ Creates: Module structure, public API, tests, documentation

+
+ +
+
šŸ”§ Intermediate: Parallel Variants
+
+ + 
"Use modular-builder to create two cache implementations: Redis-based and in-memory"
+
+

ā†’ Creates: Two parallel modules with same contract, different implementations

+
+ +
+
šŸš€ Advanced: Full Workflow
+
+ + 
"modular-builder: Build the payment processing module with Stripe integration, including retry logic, webhook handling, and comprehensive tests"
+
+

ā†’ Creates: Complete module with external integration, error handling, tests, fixtures

+
+
+
+ +
+ šŸ¤ Integration Workflow +
+

Complete Development Flow:

+ 
1. zen-architect analyzes and creates spec
+2. modular-builder implements from spec
+3. test-coverage verifies edge cases
+4. bug-hunter validates implementation
+5. post-task-cleanup ensures hygiene
+
+
+
+
+ +
+
+
bug-hunter
+ Debugging +
+
+

+ The systematic debugger that finds root causes, not just symptoms. Uses pattern recognition, binary search debugging, + and proven methodologies. Tracks down race conditions, memory leaks, and those "impossible" bugs that only happen in production. +

+
+

Key Capabilities

+
    +
  • 5-why root cause analysis
    • +
  • Pattern-based bug detection
    • +
  • Binary search debugging
    • +
  • Race condition identification
    • +
  • Memory leak detection
    • +
  • Production issue diagnosis
    • +
  • Fix verification strategies
    • +
+
+ +
+ šŸ“š Practical Examples +
+
+
šŸŽÆ Simple: API Failure
+
+ + 
"bug-hunter: Find why POST /api/users returns 500 errors intermittently"
+
+

ā†’ Analyzes: Request patterns, error logs, database state, identifies root cause

+
+ +
+
šŸ”§ Intermediate: Performance Issue
+
+ + 
"Use bug-hunter to diagnose why the app slows down after 2 hours of runtime"
+
+

ā†’ Investigates: Memory patterns, connection pools, cache behavior, finds leak

+
+ +
+
šŸš€ Advanced: Race Condition
+
+ + 
"bug-hunter: Users report duplicate charges but we can't reproduce it locally"
+
+

ā†’ Deploys: Timing analysis, transaction logs, identifies race window, provides fix

+
+
+
+ +
+ āš ļø When to Use +
    +
  • Intermittent failures that are hard to reproduce
    • +
  • Performance degradation over time
    • +
  • "Works on my machine" problems
    • +
  • After deployment when issues surface
    • +
  • Complex multi-component failures
    • +
+
+
+
+ +
+
+
test-coverage
+ Testing +
+
+

+ The testing strategist that thinks like a hacker, user, and maintainer simultaneously. Identifies edge cases others miss, + builds comprehensive test pyramids (60% unit, 30% integration, 10% E2E), and ensures your code handles the unexpected gracefully. +

+
+

Key Capabilities

+
    +
  • Test pyramid strategy (60/30/10)
    • +
  • Edge case discovery
    • +
  • Mutation testing insights
    • +
  • Property-based test generation
    • +
  • Coverage gap analysis
    • +
  • Test fixture creation
    • +
  • Performance test design
    • +
+
+ +
+ šŸ“š Practical Examples +
+
+
šŸŽÆ Simple: Add Missing Tests
+
+ + 
"test-coverage: Add comprehensive tests for the UserService class"
+
+

ā†’ Creates: Unit tests, edge cases, mocks, fixtures, 90%+ coverage

+
+ +
+
šŸ”§ Intermediate: Integration Testing
+
+ + 
"Have test-coverage design integration tests for our payment flow with Stripe"
+
+

ā†’ Creates: API mocks, webhook tests, error scenarios, retry logic tests

+
+ +
+
šŸš€ Advanced: Chaos Engineering
+
+ + 
"test-coverage: Create resilience tests simulating network failures, timeouts, and data corruption"
+
+

ā†’ Creates: Failure injection tests, recovery verification, monitoring checks

+
+
+
+ +
+ šŸŽÆ Edge Cases to Test +
    +
  • Null, undefined, empty inputs
    • +
  • Boundary values (0, -1, MAX_INT)
    • +
  • Concurrent access scenarios
    • +
  • Network timeouts and retries
    • +
  • Malformed data handling
    • +
  • Permission and auth failures
    • +
+
+
+
+ +
+
+
api-contract-designer
+ API Design +
+
+

+ The API architect who designs contracts developers love. Creates consistent, intuitive APIs with proper versioning, + comprehensive error handling, and evolution strategies. Follows REST principles while pragmatically breaking them when it makes sense. +

+
+

Key Capabilities

+
    +
  • RESTful design principles
    • +
  • OpenAPI/Swagger specifications
    • +
  • Semantic versioning strategies
    • +
  • Idempotency patterns
    • +
  • Rate limiting design
    • +
  • Error response standards
    • +
  • HATEOAS when appropriate
    • +
+
+ +
+ šŸ“š Practical Examples +
+
+
šŸŽÆ Simple: CRUD Endpoints
+
+ + 
"api-contract-designer: Design REST endpoints for user management"
+
+

ā†’ Returns: OpenAPI spec, endpoints, status codes, request/response schemas

+
+ +
+
šŸ”§ Intermediate: Webhook System
+
+ + 
"Use api-contract-designer to create webhook contracts with retry and verification"
+
+

ā†’ Returns: Webhook payload specs, HMAC verification, retry policies, event types

+
+ +
+
šŸš€ Advanced: API Evolution
+
+ + 
"api-contract-designer: Migrate v1 API to v2 with backward compatibility and deprecation strategy"
+
+

ā†’ Returns: Migration path, compatibility layer, deprecation timeline, client upgrade guide

+
+
+
+ +
+ āœ… API Best Practices +
    +
  • Use consistent naming (camelCase or snake_case)
    • +
  • Version via URL path (/v1/) or headers
    • +
  • Return proper HTTP status codes
    • +
  • Include request IDs for tracing
    • +
  • Implement pagination for lists
    • +
  • Use ISO 8601 for dates
    • +
+
+
+
+
+
+ + +
+

šŸ” Analysis & Optimization

+

+ Agents specialized in security analysis, performance optimization, and system analysis for production-ready applications. +

+
+
+
+
security-guardian
+ Security +
+
+

+ The paranoid protector who thinks like an attacker. Performs comprehensive security audits, identifies OWASP Top 10 vulnerabilities, + and ensures defense-in-depth. Reviews authentication, authorization, data protection, and input validation with zero-trust mindset. +

+
+

Key Capabilities

+
    +
  • OWASP Top 10 vulnerability detection
    • +
  • Authentication & authorization review
    • +
  • SQL injection & XSS prevention
    • +
  • Secrets management audit
    • +
  • Encryption implementation review
    • +
  • API security assessment
    • +
  • Dependency vulnerability scanning
    • +
+
+ +
+ šŸ“š Practical Examples +
+
+
šŸŽÆ Simple: Auth Review
+
+ + 
"security-guardian: Review the login endpoint for security vulnerabilities"
+
+

ā†’ Checks: Password hashing, rate limiting, session management, CSRF protection

+
+ +
+
šŸ”§ Intermediate: API Security
+
+ + 
"Have security-guardian audit our REST API for authorization bypasses and data leaks"
+
+

ā†’ Analyzes: IDOR vulnerabilities, permission checks, data exposure, rate limits

+
+ +
+
šŸš€ Advanced: Full Audit
+
+ + 
"security-guardian: Perform complete security audit including dependencies, secrets, and infrastructure"
+
+

ā†’ Delivers: Vulnerability report, risk matrix, remediation priorities, security roadmap

+
+
+
+ +
+ šŸ›”ļø Security Checklist +
    +
  • āœ“ Input validation on all user data
    • +
  • āœ“ Parameterized queries (no SQL injection)
    • +
  • āœ“ XSS protection (output encoding)
    • +
  • āœ“ HTTPS everywhere
    • +
  • āœ“ Secure session management
    • +
  • āœ“ Rate limiting on all endpoints
    • +
  • āœ“ Secrets in environment variables
    • +
  • āœ“ Dependency vulnerability scanning
    • +
+
+
+
+ +
+
+
performance-optimizer
+ Performance +
+
+

+ The speed demon who makes everything faster. Identifies bottlenecks through profiling, implements caching strategies, + optimizes algorithms from O(nĀ²) to O(n log n), and knows when to trade memory for speed. Thinks in microseconds, not milliseconds. +

+
+

Key Capabilities

+
    +
  • CPU & memory profiling
    • +
  • Algorithm complexity analysis
    • +
  • Database query optimization
    • +
  • Caching strategy design
    • +
  • Lazy loading implementation
    • +
  • Async/parallel processing
    • +
  • Memory leak detection
    • +
+
+ +
+ šŸ“š Practical Examples +
+
+
šŸŽÆ Simple: Slow Endpoint
+
+ + 
"performance-optimizer: The /api/search endpoint takes 5 seconds to respond"
+
+

ā†’ Optimizes: Adds indexes, implements caching, reduces N+1 queries

+
+ +
+
šŸ”§ Intermediate: Memory Issues
+
+ + 
"Use performance-optimizer to fix high memory usage in data processing pipeline"
+
+

ā†’ Implements: Streaming, chunking, garbage collection optimization, memory pools

+
+ +
+
šŸš€ Advanced: System-Wide
+
+ + 
"performance-optimizer: Achieve 10x performance improvement for real-time analytics"
+
+

ā†’ Delivers: Architecture changes, caching layers, async processing, horizontal scaling

+
+
+
+ +
+ āš” Performance Targets +
    +
  • API response: < 200ms (p95)
    • +
  • Database queries: < 100ms
    • +
  • Page load: < 3 seconds
    • +
  • Memory usage: < 512MB baseline
    • +
  • CPU usage: < 70% sustained
    • +
+
+
+
+ +
+
+
database-architect
+ Database +
+
+

+ The data strategist who designs schemas that scale from 100 to 100 million records. Masters both SQL and NoSQL, + knows when to normalize vs denormalize, and creates migration strategies that work without downtime. +

+
+

Key Capabilities

+
    +
  • Schema design & normalization
    • +
  • Index optimization strategies
    • +
  • Query performance tuning
    • +
  • Sharding & partitioning
    • +
  • Migration without downtime
    • +
  • SQL vs NoSQL selection
    • +
  • Transaction design
    • +
+
+ +
+ šŸ“š Practical Examples +
+
+
šŸŽÆ Simple: Schema Design
+
+ + 
"database-architect: Design schema for e-commerce order system"
+
+

ā†’ Creates: Tables, relationships, indexes, constraints, sample queries

+
+ +
+
šŸ”§ Intermediate: Performance Fix
+
+ + 
"Have database-architect optimize our slow reporting queries (taking 30+ seconds)"
+
+

ā†’ Analyzes: Execution plans, adds indexes, rewrites queries, suggests materialized views

+
+ +
+
šŸš€ Advanced: Scale Strategy
+
+ + 
"database-architect: Plan migration from single PostgreSQL to sharded cluster for 10x growth"
+
+

ā†’ Designs: Sharding strategy, migration phases, zero-downtime cutover, rollback plan

+
+
+
+ +
+ šŸ’” When to Choose +
    +
  • SQL: Complex relationships, ACID requirements
    • +
  • NoSQL: Flexible schema, horizontal scaling
    • +
  • Time-series: Metrics, logs, IoT data
    • +
  • Graph: Social networks, recommendations
    • +
  • Cache: Redis for sessions, hot data
    • +
+
+
+
+ +
+
+
integration-specialist
+ Integration +
+
+

+ The connectivity expert who makes disparate systems talk seamlessly. Masters retry logic, circuit breakers, + and graceful degradation. Handles authentication flows, webhooks, and rate limits while keeping integrations simple and maintainable. +

+
+

Key Capabilities

+
    +
  • REST/GraphQL/gRPC integration
    • +
  • OAuth/JWT authentication flows
    • +
  • Webhook implementation
    • +
  • Circuit breaker patterns
    • +
  • Exponential backoff retry
    • +
  • Rate limit handling
    • +
  • MCP server connections
    • +
+
+ +
+ šŸ“š Practical Examples +
+
+
šŸŽÆ Simple: Payment API
+
+ + 
"integration-specialist: Connect to Stripe for payment processing"
+
+

ā†’ Implements: API client, webhook handler, idempotency, error handling

+
+ +
+
šŸ”§ Intermediate: Multi-Service
+
+ + 
"Use integration-specialist to orchestrate between CRM, email, and analytics services"
+
+

ā†’ Creates: Service adapters, event bus, failure isolation, monitoring

+
+ +
+
šŸš€ Advanced: MCP Setup
+
+ + 
"integration-specialist: Set up MCP server for knowledge base with SSE events"
+
+

ā†’ Configures: MCP protocol, SSE streams, reconnection logic, state sync

+
+
+
+ +
+ šŸ”„ Resilience Patterns +
    +
  • Retry with exponential backoff
    • +
  • Circuit breaker (fail fast)
    • +
  • Bulkhead (isolate failures)
    • +
  • Timeout settings per service
    • +
  • Graceful degradation
    • +
  • Health check endpoints
    • +
+
+
+
+
+
+ + +
+

šŸ§  Knowledge & Insights

+

+ Agents that work with documentation, extract insights, and manage knowledge for better decision-making and learning. +

+
+
+
+
insight-synthesizer
+ Analysis +
+
+

+ The revolutionary thinker who finds breakthrough connections others miss. Discovers simplification cascades, + identifies meta-patterns across domains, and creates "collision zones" where unrelated ideas spark innovation. + Turns complexity into elegant simplicity. +

+
+

Key Capabilities

+
    +
  • Cross-domain pattern recognition
    • +
  • Simplification cascade discovery
    • +
  • Revolutionary connection finding
    • +
  • Meta-pattern identification
    • +
  • Collision-zone thinking
    • +
  • Complexity reduction strategies
    • +
  • Innovation through synthesis
    • +
+
+ +
+ šŸ“š Practical Examples +
+
+
šŸŽÆ Simple: Pattern Discovery
+
+ + 
"insight-synthesizer: Find patterns in our error logs and user complaints"
+
+

ā†’ Discovers: Hidden correlations, root patterns, unexpected connections

+
+ +
+
šŸ”§ Intermediate: Simplification
+
+ + 
"Use insight-synthesizer to find ways to simplify our 15-module auth system"
+
+

ā†’ Identifies: Redundancies, cascade opportunities, 3-module solution

+
+ +
+
šŸš€ Advanced: Innovation
+
+ + 
"insight-synthesizer: Connect our ML failures, API design, and UI issues to find breakthrough"
+
+

ā†’ Reveals: Meta-pattern, revolutionary approach, 10x simplification

+
+
+
+ +
+ šŸ’” When to Deploy +
    +
  • Stuck on complex problems
    • +
  • Need fresh perspective
    • +
  • Seeking radical simplification
    • +
  • Cross-domain challenges
    • +
  • Innovation opportunities
    • +
  • Pattern recognition tasks
    • +
+
+
+
+ +
+
+
knowledge-archaeologist
+ Documentation +
+
+

+ The time traveler who excavates the fossil record of ideas. Traces how concepts evolved, why paradigms shifted, + and which abandoned approaches might solve today's problems. Preserves institutional knowledge and prevents repeating past mistakes. +

+
+

Key Capabilities

+
    +
  • Temporal knowledge analysis
    • +
  • Decision lineage tracing
    • +
  • Paradigm shift documentation
    • +
  • Abandoned idea revival
    • +
  • Evolution pattern recognition
    • +
  • Context reconstruction
    • +
  • Institutional memory preservation
    • +
+
+ +
+ šŸ“š Practical Examples +
+
+
šŸŽÆ Simple: Decision History
+
+ + 
"knowledge-archaeologist: Why did we choose microservices over monolith?"
+
+

ā†’ Traces: Original requirements, decision points, trade-offs, evolution

+
+ +
+
šŸ”§ Intermediate: Pattern Evolution
+
+ + 
"Use knowledge-archaeologist to trace how our API design patterns evolved"
+
+

ā†’ Maps: Pattern genealogy, paradigm shifts, lessons learned, revival opportunities

+
+ +
+
šŸš€ Advanced: Paradigm Analysis
+
+ + 
"knowledge-archaeologist: Find valuable abandoned ideas from our 5-year history"
+
+

ā†’ Discovers: Ahead-of-time ideas, changed contexts, revival candidates

+
+
+
+ +
+ šŸ“œ What It Preserves +
    +
  • Why decisions were made
    • +
  • What alternatives were considered
    • +
  • Which constraints existed then
    • +
  • How requirements evolved
    • +
  • When paradigms shifted
    • +
  • What lessons were learned
    • +
+
+
+
+ +
+
+
concept-extractor
+ Knowledge +
+
+

+ The knowledge miner who transforms documents into structured intelligence. Extracts atomic concepts, maps relationships, + and preserves productive tensions between conflicting viewpoints. Builds queryable knowledge bases from unstructured content. +

+
+

Key Capabilities

+
    +
  • Atomic concept extraction
    • +
  • Relationship mapping (SPO triples)
    • +
  • Tension preservation
    • +
  • Knowledge graph building
    • +
  • Multi-perspective tracking
    • +
  • Contradiction identification
    • +
  • Semantic clustering
    • +
+
+ +
+ šŸ“š Practical Examples +
+
+
šŸŽÆ Simple: Document Processing
+
+ + 
"concept-extractor: Process this architecture document into concepts"
+
+

ā†’ Extracts: Key concepts, relationships, definitions, dependencies

+
+ +
+
šŸ”§ Intermediate: Multi-Document
+
+ + 
"Use concept-extractor on all microservices documentation"
+
+

ā†’ Creates: Unified knowledge graph, service relationships, capability map

+
+ +
+
šŸš€ Advanced: Conflict Analysis
+
+ + 
"concept-extractor: Extract and preserve tensions between these competing proposals"
+
+

ā†’ Maps: Conflicting viewpoints, trade-offs, productive tensions, decision space

+
+
+
+ +
+ šŸ“Š Output Formats +
    +
  • Knowledge graph (NetworkX)
    • +
  • SPO triples (subject-predicate-object)
    • +
  • Concept hierarchy
    • +
  • Relationship matrix
    • +
  • Tension points documentation
    • +
  • Queryable JSON structure
    • +
+
+
+
+ +
+
+
ambiguity-guardian
+ Analysis +
+
+

+ Preserves productive contradictions and identifies areas where ambiguity might be valuable. + Prevents premature optimization and maintains flexibility where needed. +

+
+

Key Capabilities

+
    +
  • Ambiguity identification
    • +
  • Flexibility preservation
    • +
  • Contradiction analysis
    • +
  • Decision deferral strategies
    • +
+
+
+ "Have ambiguity-guardian review feature requirements" +
+
+
+ +
+
+
content-researcher
+ Research +
+
+

+ Researches from content collection, finding relevant information and connecting ideas. + Acts as your intelligent research assistant for technical documentation and decisions. +

+
+

Key Capabilities

+
    +
  • Content research
    • +
  • Information synthesis
    • +
  • Relevance analysis
    • +
  • Reference tracking
    • +
+
+
+ "Use content-researcher to find database patterns" +
+
+
+
+
+ + +
+

šŸ”§ Meta & Support

+

+ Agents that help manage the development environment, create new specialized agents, and maintain codebase hygiene. +

+
+
+
+
subagent-architect
+ Meta +
+
+

+ The agent creator who designs new specialized experts for your unique needs. Analyzes your workflow, + identifies capability gaps, and creates custom agents with precise expertise. Your personal AI team builder. +

+
+

Key Capabilities

+
    +
  • Custom agent creation
    • +
  • Expertise specification
    • +
  • Workflow gap analysis
    • +
  • Tool integration design
    • +
  • Prompt engineering
    • +
  • Agent testing & validation
    • +
  • Performance optimization
    • +
+
+ +
+ šŸ“š Practical Examples +
+
+
šŸŽÆ Simple: Framework Expert
+
+ + 
"subagent-architect: Create a React + TypeScript specialist agent"
+
+

ā†’ Creates: Agent with React patterns, hooks expertise, TypeScript best practices

+
+ +
+
šŸ”§ Intermediate: Domain Expert
+
+ + 
"Use subagent-architect to build a healthcare compliance agent for HIPAA"
+
+

ā†’ Creates: Specialized agent with regulatory knowledge, audit capabilities

+
+ +
+
šŸš€ Advanced: Workflow Agent
+
+ + 
"subagent-architect: Design multi-agent workflow for continuous deployment pipeline"
+
+

ā†’ Creates: Agent team with build, test, deploy, monitor specializations

+
+
+
+ +
+ šŸŽÆ Agent Design Tips +
    +
  • Start with specific, narrow expertise
    • +
  • Define clear trigger conditions
    • +
  • Include concrete examples
    • +
  • Specify integration points
    • +
  • Test with real scenarios
    • +
  • Iterate based on performance
    • +
+
+
+
+ +
+
+
post-task-cleanup
+ Maintenance +
+
+

+ The janitor who keeps your codebase pristine. Runs after tasks to remove debug code, eliminate unnecessary complexity, + update documentation, and ensure philosophy compliance. Your automated technical debt preventer. +

+
+

Key Capabilities

+
    +
  • Debug artifact removal
    • +
  • Complexity elimination
    • +
  • Documentation sync
    • +
  • Import optimization
    • +
  • Dead code removal
    • +
  • Consistency enforcement
    • +
  • Philosophy compliance
    • +
+
+ +
+ šŸ“š Practical Examples +
+
+
šŸŽÆ Simple: After Feature
+
+ + 
"post-task-cleanup: Clean up after implementing user registration"
+
+

ā†’ Removes: Console.logs, TODO comments, unused imports, test artifacts

+
+ +
+
šŸ”§ Intermediate: Module Review
+
+ + 
"Use post-task-cleanup to review and simplify the payment module"
+
+

ā†’ Simplifies: Removes abstractions, consolidates files, updates docs

+
+ +
+
šŸš€ Advanced: Codebase Audit
+
+ + 
"post-task-cleanup: Full codebase hygiene check and philosophy compliance"
+
+

ā†’ Delivers: Cleanup report, technical debt list, simplification opportunities

+
+
+
+ +
+ šŸ§¹ Cleanup Checklist +
    +
  • Remove console.log statements
    • +
  • Delete commented-out code
    • +
  • Remove TODO without action
    • +
  • Optimize imports
    • +
  • Delete unused variables
    • +
  • Update stale documentation
    • +
  • Enforce naming conventions
    • +
+
+
+
+
+
+ + +
+

How to Use Agents

+
+
+

Automatic Invocation

+

+ Claude automatically selects and invokes the most appropriate agent based on your request. + Simply describe your task naturally, and the system will delegate to the right specialist. +

+
+
+

Explicit Invocation

+

+ You can also explicitly request specific agents by name: +

+
+ "Use zen-architect to design my user management system"
+"Have bug-hunter investigate the login timeout issue"
+"Deploy security-guardian to review the API endpoints" +
+
+
+

Creating Custom Agents

+

+ Use the subagent-architect to create specialized agents for your unique needs, + or use the /agents command to create them interactively. +

+
+
+
+
+
+
+ + + + + + + \ No newline at end of file diff --git a/instructor/examples.html b/instructor/examples.html new file mode 100644 index 00000000..b06aa335 --- /dev/null +++ b/instructor/examples.html @@ -0,0 +1,1721 @@ + + + + + + Examples & Workflows - Amplifier + + + + + + + +
+ +
+ +
+ +
+
+

Examples & Workflows

+

Real-world examples of how to use Amplifier's specialized agents and features to accelerate your development

+ +
+

āš” Ready to Copy & Paste

+

All examples include working commands you can copy directly into Claude. No guesswork, no setup - just results.

+
+ +
# Start with any workflow in 3 commands:
+
cd amplifier
+
claude
+
"Use zen-architect to design my [feature name]"
+
+
+
+
+ + +
+
+
+ + + + + +
+ + +
+
+ +
+
+
šŸ—ļø
+
+
Building a Complete Feature
+
From design to testing with specialized agents
+
+
+
+
+ + + +
+ + +
+
+

šŸŽÆ Example: Building a User Profile System

+

We'll build a complete user profile feature from scratch - user registration, profile editing, avatar upload, and privacy settings.

+
+ +
+

Step 1: Architecture Design

+

Start with zen-architect to get a clean, maintainable design:

+
+ + "Use zen-architect to design a user profile system with registration, profile editing, avatar upload, and privacy settings. Focus on simplicity and maintainability." +
+
+
āœ… What zen-architect will provide:
+ ā€¢ Problem breakdown and requirements analysis
+ ā€¢ 3 architectural approaches with trade-offs
+ ā€¢ Recommended modular structure
+ ā€¢ Database schema suggestions
+ ā€¢ API endpoint specifications +
+
+ +
+

Step 2: Module Implementation

+

Use modular-builder to create the actual code:

+
+ + "Have modular-builder implement the user profile module following the zen-architect design. Include user registration, profile CRUD operations, and avatar upload functionality." +
+
+
āœ… What modular-builder will create:
+ ā€¢ Complete module structure with clear contracts
+ ā€¢ Database models and migrations
+ ā€¢ API endpoints with proper validation
+ ā€¢ File upload handling for avatars
+ ā€¢ Privacy settings implementation +
+
+ +
+

Step 3: Comprehensive Testing

+

Deploy test-coverage to ensure everything works:

+
+ + "Deploy test-coverage to add comprehensive tests for the user profile system including unit tests, integration tests, and edge cases for file uploads and validation." +
+
+
āœ… What test-coverage will add:
+ ā€¢ Unit tests for all business logic
+ ā€¢ Integration tests for API endpoints
+ ā€¢ File upload edge cases (size limits, formats)
+ ā€¢ Validation error scenarios
+ ā€¢ Security test cases +
+
+ +
+

Step 4: Security Review

+

Have security-guardian check for vulnerabilities:

+
+ + "Have security-guardian review the user profile system for security vulnerabilities, including file upload security, input validation, and privacy controls." +
+
+
āœ… What security-guardian will check:
+ ā€¢ File upload security (malicious files)
+ ā€¢ Input validation and XSS prevention
+ ā€¢ Authentication and authorization
+ ā€¢ Privacy setting enforcement
+ ā€¢ OWASP compliance +
+
+ +
+
šŸ§Ŗ Verification Steps
+
    +
  1. Run Tests: make test - All tests should pass
    2. +
  2. Check Security: make check - No security issues
    3. +
  3. Manual Testing: Create a user, upload avatar, edit profile
    4. +
  4. Privacy Check: Verify privacy settings work correctly
    5. +
+
+ +
+
šŸšØ Common Issues
+
    +
  • File upload fails: Check file size limits and storage configuration
    • +
  • Tests fail: Run make lint to check code formatting
    • +
  • Security warnings: Review input validation and sanitization
    • +
  • Database errors: Verify migrations are applied correctly
    • +
+
+
+ + +
+
+

šŸŽÆ Example: E-commerce Cart & Checkout

+

Build a complete shopping cart with inventory management, payment processing, order history, and email notifications.

+
+ +
+
+

Step 1: Architecture & Integration Planning

+ + +
+
+
+
šŸ“‹ Command Sequence
+
1. "Use zen-architect to design an e-commerce cart system with inventory management, payment integration (Stripe), order processing, and email notifications"
+
2. "Have integration-specialist analyze the payment and email service integrations for the cart system"
+
3. "Use database-architect to optimize the cart and inventory database design for high performance"
+
+
+
āœ… Expected Results:
+ ā€¢ Microservices architecture with clear boundaries
+ ā€¢ Integration patterns for Stripe and email services
+ ā€¢ Optimized database schema with proper indexes
+ ā€¢ Inventory concurrency handling strategy
+ ā€¢ Error handling and rollback mechanisms +
+
+
+ +
+
+

Step 2: Core Implementation

+ + +
+
+
+
šŸ“‹ Command Sequence
+
1. "Have modular-builder implement the shopping cart module with session management and inventory tracking"
+
2. "Use api-contract-designer to create the checkout and payment API endpoints"
+
3. "Have modular-builder implement the order processing and email notification systems"
+
+

Key Features to Implement:

+
    +
  • Shopping cart CRUD with session persistence
    • +
  • Real-time inventory checking and reservation
    • +
  • Stripe payment processing with webhooks
    • +
  • Order status tracking and history
    • +
  • Automated email notifications
    • +
+
+
+ +
+
+

Step 3: Performance & Security

+ + +
+
+
+
šŸ“‹ Command Sequence
+
1. "Have performance-optimizer analyze the cart and checkout flow for bottlenecks"
+
2. "Use security-guardian to audit payment processing and PII handling"
+
3. "Deploy test-coverage to add comprehensive tests including payment scenarios and race conditions"
+
+
+
šŸšØ E-commerce Specific Issues
+
    +
  • Race conditions: Multiple users buying the last item
    • +
  • Payment failures: Network timeouts during payment processing
    • +
  • Inventory sync: Real-time inventory updates across sessions
    • +
  • PCI compliance: Secure handling of payment information
    • +
+
+
+
+
+ + +
+
+

šŸŽÆ Example: Multi-tenant SaaS Platform

+

Build a complete multi-tenant SaaS platform with tenant isolation, usage billing, admin dashboards, and white-label customization.

+
+ +
+
šŸ“‹ Advanced Multi-Agent Orchestration
+
# Architecture phase - multiple agents in parallel
+
1a. "Use zen-architect to design multi-tenant architecture with data isolation, tenant onboarding, and billing integration"
+
1b. "Have database-architect design tenant isolation strategies and performance optimization for multi-tenancy"
+
1c. "Use security-guardian to analyze multi-tenant security requirements and isolation boundaries"
+
# Implementation phase - coordinated development
+
2a. "Have modular-builder implement the tenant management and onboarding system"
+
2b. "Use api-contract-designer to create the admin dashboard API with tenant-scoped endpoints"
+
2c. "Have integration-specialist implement billing system integration with usage tracking"
+
# Validation phase - comprehensive testing
+
3a. "Deploy test-coverage to add multi-tenant isolation tests and billing scenarios"
+
3b. "Use performance-optimizer to test scalability with multiple tenants and high load"
+
3c. "Have security-guardian perform penetration testing for tenant isolation"
+
+ +
+
+

Advanced Techniques: Parallel Worktrees for Architecture Comparison

+ + +
+
+
+ + # Test 3 different multi-tenant approaches in parallel + make worktree tenant-shared-db # Shared database approach + make worktree tenant-separate-db # Separate database per tenant + make worktree tenant-schema-based # Schema-based isolation + + # Develop each approach with different agents + # Compare performance, security, and maintainability + make worktree-list # Review all approaches +
+

Evaluation Criteria:

+
    +
  • Data isolation effectiveness
    • +
  • Performance at scale (1000+ tenants)
    • +
  • Backup and disaster recovery complexity
    • +
  • Development and maintenance overhead
    • +
  • Cost optimization opportunities
    • +
+
+
+ +
+
šŸ§Ŗ Advanced Verification Protocol
+
    +
  1. Tenant Isolation: Verify data cannot leak between tenants
    2. +
  2. Performance Testing: Load test with 100+ concurrent tenants
    3. +
  3. Billing Accuracy: Validate usage tracking and billing calculations
    4. +
  4. Security Audit: Penetration testing for multi-tenant vulnerabilities
    5. +
  5. Disaster Recovery: Test backup/restore for individual tenants
    6. +
+
+
+
+
+ +
+
+
āš”
+
+
Rapid API Development
+
Design and implement APIs with proper contracts
+
+
+
+
+
+
1
+
+

API Contract Design api-contract-designer

+

Create clean, consistent API design with proper documentation.

+
+ > "Use api-contract-designer to create a RESTful API for user management with authentication endpoints" +
+
+
+
+
2
+
+

Implementation modular-builder

+

Build the API following the contract specifications.

+
+ > "Have modular-builder implement the user management API following the contract design" +
+
+
+
+
3
+
+

Integration Testing integration-specialist

+

Set up proper error handling and monitoring.

+
+ > "Have integration-specialist add proper error handling, retry logic, and monitoring to the API" +
+
+
+
+
+
+
+
+ + +
+
+
+
+
šŸ›
+
+
Systematic Bug Investigation
+
From symptoms to root cause to solution
+
+
+
+
+

šŸŽÆ Real Bug Hunt: "Login timeouts affecting 30% of users since yesterday"

+

A classic production issue - sudden onset, affects some users but not others, timing suggests recent change. Let's hunt it down systematically.

+
+ +
+

Step 1: Initial Triage & Information Gathering

+

Start with bug-hunter to systematically analyze symptoms:

+
+ + "Use bug-hunter to investigate login timeout errors. Issue started yesterday, affects 30% of login attempts. Users report seeing 'Connection timeout' after 10 seconds. Some users can login fine, others consistently fail." +
+
+
āœ… What bug-hunter will analyze:
+ ā€¢ Pattern analysis (affected vs unaffected users)
+ ā€¢ Timing correlation with recent deployments
+ ā€¢ Error frequency and distribution
+ ā€¢ Hypothesis generation for likely causes
+ ā€¢ Investigation plan with priorities +
+
+ +
+

Step 2: Performance Deep Dive

+

Check if performance degradation is the culprit:

+
+ + "Have performance-optimizer analyze the login flow end-to-end. Check database query times, external service calls, and identify any bottlenecks that could cause 10-second timeouts." +
+
+
āœ… What performance-optimizer will check:
+ ā€¢ Database query execution times
+ ā€¢ External API response times (auth services)
+ ā€¢ Memory and CPU usage patterns
+ ā€¢ Connection pool exhaustion
+ ā€¢ Performance regression analysis +
+
+ +
+

Step 3: Database Investigation

+

Database issues are a common culprit for intermittent timeouts:

+
+ + "Use database-architect to investigate authentication database queries. Check for missing indexes, query plan changes, lock contention, or connection pool issues that could cause intermittent timeouts." +
+
+
āœ… What database-architect will examine:
+ ā€¢ Query execution plans and index usage
+ ā€¢ Database locks and blocking sessions
+ ā€¢ Connection pool configuration and usage
+ ā€¢ Recent schema changes or data growth
+ ā€¢ Database server resource utilization +
+
+ +
+

Step 4: Knowledge Base Search

+

Check if we've seen similar issues before:

+
+ + "Use content-researcher to search our knowledge base for previous login timeout issues, authentication problems, and database performance fixes. Look for patterns and solutions we've used before." +
+
+ +
+

Step 5: Implement & Test Fix

+

Once root cause is identified, implement the solution:

+
+ + "Have modular-builder implement the login timeout fix with proper error handling, retry logic, and monitoring. Include graceful degradation and user-friendly error messages." +
+
+ +
+
šŸšØ Common Login Timeout Causes
+
    +
  • Database connection pool exhaustion: Too many concurrent requests
    • +
  • Missing database indexes: Queries getting slower as data grows
    • +
  • External auth service issues: Third-party API degradation
    • +
  • Memory leaks: Application consuming too much memory
    • +
  • Network issues: Increased latency or packet loss
    • +
+
+
+
+ + +
+
+
šŸ”’
+
+
Security Incident Response
+
Systematic security vulnerability handling
+
+
+
+
+

šŸŽÆ Security Alert: Potential SQL Injection in User Search

+

Security scanner flagged possible SQL injection vulnerability in user search functionality. Need immediate assessment and remediation.

+
+ +
+
šŸ“‹ Immediate Response Protocol
+
# Phase 1: Assessment (URGENT)
+
1. "Have security-guardian perform immediate security assessment of the user search functionality. Check for SQL injection, XSS, and other OWASP Top 10 vulnerabilities."
+
# Phase 2: Historical Analysis
+
2. "Use content-researcher to find previous SQL injection fixes and security patches in our codebase for similar patterns."
+
# Phase 3: Impact Analysis
+
3. "Have database-architect analyze what data could be exposed if the SQL injection vulnerability is exploited."
+
# Phase 4: Secure Implementation
+
4. "Have modular-builder implement secure parameterized queries and input validation for all search functionality."
+
+ +
+
+

Detailed Security Assessment Steps

+ + +
+
+
+

Vulnerability Verification

+
+ + "Security-guardian: Test the user search with these payloads to confirm vulnerability: [basic SQL injection tests]. Check if any of these return unexpected data or error messages." +
+
+ +
+

Code Review & Pattern Analysis

+
+ + "Security-guardian: Review all database query patterns in the codebase. Identify any other locations using string concatenation instead of parameterized queries." +
+
+ +
+

Data Exposure Assessment

+
+ + "Database-architect: Map out all tables accessible through the vulnerable query path. Identify sensitive data (PII, credentials, financial) that could be exposed." +
+
+
+
+ +
+
šŸ§Ŗ Security Fix Verification
+
    +
  1. Automated Testing: Run security scanner again to confirm fix
    2. +
  2. Manual Penetration Testing: Test with various SQL injection payloads
    3. +
  3. Code Review: Verify all queries use parameterized statements
    4. +
  4. Input Validation: Test with malicious input patterns
    5. +
  5. Error Handling: Ensure no sensitive info in error messages
    6. +
+
+ +
+
šŸšØ Security Incident Checklist
+
    +
  • Document everything: Keep detailed logs of assessment and fixes
    • +
  • Notify stakeholders: Inform security team and management
    • +
  • Check for exploitation: Review logs for attack attempts
    • +
  • Update security policies: Learn from the incident
    • +
  • Implement monitoring: Add alerts for similar attack patterns
    • +
+
+
+
+
+
+ + +
+
+ +
+
+
šŸ§ 
+
+
Knowledge-Driven Development
+
Transform documentation into actionable intelligence
+
+
+
+
+

šŸ“š From Docs to Intelligence in 3 Commands

+

Turn your scattered documentation into a queryable knowledge base that guides development decisions.

+
+ +
make knowledge-update
+
make knowledge-query Q="authentication patterns"
+
make knowledge-export FORMAT=markdown
+
+
+ +
+

Step 1: Extract Knowledge from Documentation

+

Process all your docs, README files, and code comments into structured knowledge:

+
+ + make knowledge-update +
+
+
āœ… What gets processed:
+ ā€¢ All Markdown files in docs/, README.md, and subdirectories
+ ā€¢ Code comments and docstrings
+ ā€¢ API specifications and architectural decisions
+ ā€¢ Issue descriptions and pull request discussions
+ ā€¢ Configuration files and deployment guides +
+
+
šŸ§Ŗ Verify Processing
+
+ + # Check what was processed + ls .data/knowledge/ # Should see extracted concepts + make knowledge-stats # Shows processing summary +
+
+
+ +
+

Step 2: Query Your Knowledge Base

+

Ask specific questions to get targeted insights:

+
+
šŸ“‹ Example Queries (Copy Any)
+
make knowledge-query Q="error handling patterns" # Find error handling approaches
+
make knowledge-query Q="database migration strategies" # Schema evolution patterns
+
make knowledge-query Q="authentication implementation" # Auth system designs
+
make knowledge-query Q="performance optimization" # Speed improvement techniques
+
make knowledge-query Q="testing strategies" # Test approaches and patterns
+
+
+
āœ… Query results include:
+ ā€¢ Relevant concepts and their relationships
+ ā€¢ Code examples and implementation patterns
+ ā€¢ Design decisions with rationale
+ ā€¢ Links to source documents
+ ā€¢ Related concepts and alternatives +
+
+ +
+

Step 3: Apply Knowledge with Agents

+

Use insights to guide implementation decisions:

+
+ + "Use insight-synthesizer to apply the error handling patterns from our knowledge base to the new payment processing module. Focus on retry strategies and circuit breaker patterns." +
+
+ + "Have content-researcher find all authentication-related patterns in our knowledge base and suggest the best approach for implementing OAuth 2.0 integration." +
+
+ +
+

Step 4: Document New Learnings

+

Capture new insights for future reference:

+
+ + # Document what you learned + echo "## Payment Processing Lessons\n\n- Stripe webhooks require idempotency keys\n- Always validate webhook signatures\n- Use exponential backoff for retries" >> docs/lessons-learned.md + + # Update knowledge base + make knowledge-update +
+
+ +
+
šŸšØ Knowledge Base Issues
+
    +
  • No results from queries: Run make knowledge-update first to process docs
    • +
  • Outdated information: Re-run knowledge update after doc changes
    • +
  • Irrelevant results: Make queries more specific ("React authentication" vs "authentication")
    • +
  • Processing errors: Check .data/knowledge/ for error logs
    • +
+
+
+
+ + +
+
+
šŸ”
+
+
Deep Research & Discovery
+
Uncover hidden connections and insights
+
+
+
+
+

šŸŽÆ Discovery Mission: "Why do our microservices keep having the same problems?"

+

Use knowledge archaeology and concept extraction to identify recurring patterns and systemic issues across your architecture.

+
+ +
+
+

Phase 1: Concept Extraction from System Documentation

+ + +
+
+
+ + "Use concept-extractor to analyze all our microservice documentation, incident reports, and architectural decision records. Extract recurring concepts, failure patterns, and design decisions." +
+
+
āœ… Concepts identified might include:
+ ā€¢ Service communication patterns (sync vs async)
+ ā€¢ Failure modes and recovery strategies
+ ā€¢ Data consistency approaches
+ ā€¢ Deployment and scaling patterns
+ ā€¢ Monitoring and observability strategies +
+
+
+ +
+
+

Phase 2: Connection Discovery

+ + +
+
+
+ + "Have insight-synthesizer find hidden connections between our service failures, deployment patterns, and team organization. Look for correlations we might have missed." +
+
+ + "Use pattern-emergence to identify system-level patterns from our incident reports. What commonalities exist across different service failures?" +
+
+
+ +
+
+

Phase 3: Evolution Analysis

+ + +
+
+
+ + "Use knowledge-archaeologist to trace how our microservice architecture evolved. Which decisions led to current pain points? What alternatives were considered but abandoned?" +
+
+
āœ… Evolutionary insights:
+ ā€¢ Decision timeline and rationale
+ ā€¢ Abandoned approaches and why
+ ā€¢ Evolution of complexity over time
+ ā€¢ Recurring decision points
+ ā€¢ Lessons from architecture changes +
+
+
+ +
+

Step 4: Synthesis & Actionable Insights

+

Turn discoveries into concrete improvements:

+
+ + "Have insight-synthesizer create an actionable improvement plan based on the discovered patterns. Focus on the top 3 recurring issues and practical solutions." +
+
+ + "Use visualization-architect to create a visual map of the discovered connections and patterns for team discussion and planning." +
+
+ +
+
šŸ§Ŗ Research Validation
+
    +
  1. Pattern Verification: Validate discovered patterns with team members
    2. +
  2. Historical Accuracy: Cross-check findings with incident timelines
    3. +
  3. Actionability: Ensure insights lead to concrete next steps
    4. +
  4. Documentation: Capture discoveries in architectural decision records
    5. +
+
+
+
+
+
+ + +
+
+
+
+
āš”
+
+
Performance Optimization
+
Data-driven approach to eliminating bottlenecks
+
+
+
+
+

šŸŽÆ Performance Crisis: "Checkout takes 15+ seconds, users are abandoning carts"

+

E-commerce site seeing 40% cart abandonment during checkout. Need systematic performance analysis and optimization.

+
+ +
+

Step 1: Performance Profiling & Baseline

+

Get concrete data on where time is being spent:

+
+ + "Use performance-optimizer to profile the entire checkout flow. Measure database query times, API response times, and frontend rendering. Identify the top 5 bottlenecks by impact." +
+
+
āœ… Performance analysis will show:
+ ā€¢ Request timeline with precise timing breakdown
+ ā€¢ Database queries ranked by execution time
+ ā€¢ External API calls and their response times
+ ā€¢ Memory usage and potential leaks
+ ā€¢ Frontend performance metrics and bottlenecks +
+
+ +
+

Step 2: Database Query Optimization

+

Often the biggest performance wins come from database optimization:

+
+ + "Have database-architect analyze all checkout-related queries. Focus on the product inventory check, payment processing, and order creation queries. Add indexes and optimize query plans." +
+
+
šŸ“‹ Common Database Optimizations
+
# Check current performance
+
"Database-architect: Show query execution plans for checkout process"
+
# Optimize slow queries
+
"Add indexes for inventory.product_id, orders.user_id, payments.status"
+
# Connection pool tuning
+
"Optimize database connection pool size for checkout load"
+
+
+ +
+

Step 3: Caching Strategy Implementation

+

Add strategic caching to reduce repeated expensive operations:

+
+ + "Have modular-builder implement a multi-tier caching strategy: Redis for session data, application-level cache for product info, and CDN for static assets. Focus on checkout flow optimization." +
+
+
+

Detailed Caching Implementation

+ + +
+
+
+ + # Session & Cart Caching + "Cache user cart contents in Redis with 1-hour TTL" + "Implement cart persistence across browser sessions" + + # Product Information Caching + "Cache product details and pricing for 10 minutes" + "Use cache warming for popular products" + + # Payment & Inventory Caching + "Cache inventory counts with real-time invalidation" + "Implement payment method validation caching" +
+
+
+
+ +
+

Step 4: Frontend Performance Optimization

+

Optimize the user experience with frontend improvements:

+
+ + "Use performance-optimizer to analyze frontend checkout performance. Implement lazy loading, optimize bundle sizes, and add progressive loading indicators." +
+
+
āœ… Frontend optimizations:
+ ā€¢ Bundle size reduction through code splitting
+ ā€¢ Progressive loading with skeleton screens
+ ā€¢ Image optimization and lazy loading
+ ā€¢ Critical CSS inlining
+ ā€¢ Service worker for caching static assets +
+
+ +
+

Step 5: Performance Testing & Monitoring

+

Ensure optimizations work and stay optimized:

+
+ + "Deploy test-coverage to add performance tests for checkout flow. Include load testing scenarios, response time assertions, and performance regression detection." +
+
+
šŸ§Ŗ Performance Verification
+
    +
  1. Baseline Comparison: Measure before/after performance
    2. +
  2. Load Testing: Test with 100+ concurrent users
    3. +
  3. Real User Monitoring: Track actual user experience
    4. +
  4. Alerting: Set up alerts for performance degradation
    5. +
+
+
+ +
+
šŸšØ Common Performance Optimization Pitfalls
+
    +
  • Premature optimization: Optimize based on data, not assumptions
    • +
  • Cache invalidation issues: Stale data causing user confusion
    • +
  • Over-caching: Memory usage growing out of control
    • +
  • Database index bloat: Too many indexes slowing writes
    • +
  • Network latency ignored: Focusing only on server performance
    • +
+
+
+
+ + +
+
+
šŸ“ˆ
+
+
Advanced Performance Engineering
+
Scaling and optimization at enterprise level
+
+
+
+
+
šŸ“‹ Enterprise Performance Workflow
+
# Multi-agent performance analysis
+
1. "Use performance-optimizer to establish comprehensive performance baselines across all services"
+
2. "Have database-architect design sharding strategy for high-volume tables"
+
3. "Use integration-specialist to optimize microservice communication patterns"
+
4. "Have zen-architect design auto-scaling architecture with predictive scaling"
+
# Continuous optimization loop
+
5. "Deploy test-coverage to add automated performance regression testing"
+
6. "Use visualization-architect to create performance dashboards and alerts"
+
+ +
+
+

Scaling Strategy: Handling 10x Growth

+ + +
+
+
+

Scenario: Black Friday Traffic Spike

+

Prepare system to handle 10x normal traffic during peak shopping events. Need automatic scaling, graceful degradation, and zero downtime.

+
+
+ + "Use zen-architect to design auto-scaling architecture that can handle 10x traffic spikes. Include circuit breakers, graceful degradation, and automatic failover mechanisms." +
+

Key scaling components:

+
    +
  • Horizontal auto-scaling based on metrics
    • +
  • Database read replicas and connection pooling
    • +
  • CDN and edge caching for static content
    • +
  • Queue-based async processing for non-critical tasks
    • +
  • Circuit breakers for external service calls
    • +
+
+
+
+
+
+
+ + +
+
+
+
+
šŸŒ³
+
+
Parallel Development
+
Explore multiple approaches simultaneously
+
+
+
+

+ Stop wondering "what if" ā€” build multiple solutions simultaneously and pick the winner. + Each worktree is completely isolated with its own branch, environment, and context. +

+ +
+

Example: Authentication System Comparison

+
+
$ make worktree feature-jwt
+
# Creates isolated JWT authentication approach

+ +
$ make worktree feature-oauth
+
# Creates parallel OAuth 2.0 approach

+ +
$ make worktree feature-session
+
# Creates third approach with session-based auth

+ +
$ make worktree-list
+
# Compare all approaches
+
+ ā€¢ main (current) + ā€¢ feature-jwt (JWT tokens + refresh) + ā€¢ feature-oauth (OAuth 2.0 + PKCE) + ā€¢ feature-session (server sessions + Redis) +
+
+
+ +
+
+
1
+
+

Create Parallel Branches

+

Set up isolated environments for each approach.

+
+ make worktree approach-1
+ make worktree approach-2
+ make worktree approach-3 +
+
+
+
+
2
+
+

Develop in Parallel

+

Use different agents or approaches in each worktree.

+
+ Worktree 1: "Use zen-architect for microservices approach"
+ Worktree 2: "Use modular-builder for monolithic approach"
+ Worktree 3: "Use api-contract-designer for serverless approach" +
+
+
+
+
3
+
+

Compare and Evaluate

+

Test and compare all approaches to find the best solution.

+
+ make worktree-list # Review all approaches
+ > "Compare the performance and maintainability of all three approaches" +
+
+
+
+
4
+
+

Choose and Clean Up

+

Select the best approach and remove the others.

+
+ git merge feature-jwt # Merge the winning approach
+ make worktree-rm approach-2
+ make worktree-rm approach-3 +
+
+
+
+
+
+
+
+
+
+ + +
+
+

Quick Reference Commands

+
+
+

šŸ—ļø Architecture & Design

+
"Use zen-architect to design my user management system"
+
+
+

šŸ› Bug Investigation

+
"Deploy bug-hunter to find why login is failing"
+
+
+

šŸ”’ Security Review

+
"Have security-guardian audit my API endpoints"
+
+
+

āš” Performance Optimization

+
"Use performance-optimizer to speed up database queries"
+
+
+

šŸ“ API Design

+
"Have api-contract-designer create REST endpoints for orders"
+
+
+

šŸ§Ŗ Testing

+
"Deploy test-coverage to add comprehensive test suite"
+
+
+

šŸ§  Knowledge Query

+
make knowledge-query Q="authentication patterns"
+
+
+

šŸŒ³ Parallel Development

+
make worktree feature-name
+
+
+
+
+ + +
+
+

Pro Tips

+
+
+
šŸŽÆ
+

Be Specific

+

The more specific your request, the better the agent can help. Include context about your goals, constraints, and requirements.

+
+
+
šŸ”„
+

Chain Agents

+

Use multiple agents in sequence. Start with zen-architect for design, then modular-builder for implementation, then test-coverage for testing.

+
+
+
šŸ“š
+

Build Knowledge

+

Regularly run 'make knowledge-update' to keep your knowledge base current. The more knowledge you have, the better the insights.

+
+
+
šŸŒŸ
+

Experiment Freely

+

Use parallel worktrees to try different approaches without risk. You can always discard experiments that don't work out.

+
+
+
šŸ”
+

Leverage Context

+

Agents have access to your entire codebase context. They can understand existing patterns and maintain consistency.

+
+
+
āš”
+

Iterate Quickly

+

Don't try to solve everything at once. Use agents for focused tasks and iterate based on results.

+
+
+
+
+
+ + + + + + + \ No newline at end of file diff --git a/instructor/index.html b/instructor/index.html new file mode 100644 index 00000000..116c4874 --- /dev/null +++ b/instructor/index.html @@ -0,0 +1,361 @@ + + + + + + Amplifier - Supercharged AI Development Environment + + + + + + +
+ +
+ +
+ +
+
+

Turn AI Assistants into Force Multipliers

+

A complete development environment that supercharges AI coding assistants with discovered patterns, specialized expertise, and powerful automation.

+
+ Get Started + View on GitHub +
+
+
"I have more ideas than time to try them out" ā€” The problem we're solving
+
+
+
+
+
+
+ + + +
+ claude +
+
+
+ $ + claude +
+
+ Use zen-architect to design my notification system +
+
+ [zen-architect] + Designing with ruthless simplicity... +
+
+
+
+
+ + +
+
+

What Is Amplifier?

+
+
+
šŸ¤–
+

20+ Specialized Agents

+

Each expert in specific tasks like architecture, debugging, security, and testing.

+
+
+
šŸ§ 
+

Pre-loaded Context

+

Proven patterns and philosophies built into the environment from day one.

+
+
+
šŸŒ³
+

Parallel Worktree System

+

Build and test multiple solutions simultaneously without conflicts.

+
+
+
šŸ“š
+

Knowledge Extraction

+

Transform documentation into queryable, connected knowledge graphs.

+
+
+
+
+ + +
+
+

Key Features

+
+
+ + + + +
+ +
+
+
+

Specialized Agents

+

Instead of one generalist AI, you get 20+ specialists, each expert in specific domains:

+
    +
  • zen-architect - Designs with ruthless simplicity
    • +
  • bug-hunter - Systematic debugging approach
    • +
  • security-guardian - Security analysis and vulnerability detection
    • +
  • test-coverage - Comprehensive testing strategies
    • +
  • performance-optimizer - Performance profiling and optimization
    • +
+ View All Agents +
+
+
+
+
+ zen-architect + Architecture +
+

Designs systems with ruthless simplicity, focusing on essential patterns and clean abstractions.

+
+
+
+
+
+ +
+
+
+

Knowledge Base System

+

Stop losing insights. Every document becomes part of your permanent, queryable knowledge:

+
    +
  • Extract concepts and relationships from documentation
    • +
  • Query accumulated wisdom instantly
    • +
  • Visualize how ideas connect
    • +
  • Share knowledge across all worktrees
    • +
+
+ make knowledge-update # Extract from docs
+make knowledge-query Q="auth patterns" +
+
+
+
+
Authentication
+
Security
+
Patterns
+
+
+
+
+
+ +
+
+
+

Parallel Development

+

Stop wondering "what if" ā€” build multiple solutions simultaneously:

+
    +
  • Try different approaches in parallel worktrees
    • +
  • Compare implementations side by side
    • +
  • Keep the best, discard the rest
    • +
  • Each worktree is completely isolated
    • +
+
+ make worktree feature-jwt # JWT approach
+make worktree feature-oauth # OAuth approach
+make worktree-list # Compare both +
+
+
+
+
+ main +
+
+
+ feature-jwt +
+
+
+ feature-oauth +
+
+
+
+
+
+ +
+
+
+

Modular Builder

+

One-command workflow from idea to working module:

+
    +
  • Contract & Spec ā†’ Plan ā†’ Generate ā†’ Review
    • +
  • Auto or assisted modes
    • +
  • Built-in conformance testing
    • +
  • Resume from any point
    • +
+
+ /modular-build Build a notification system
+mode: auto level: moderate +
+
+
+
+
Contract
+
ā†’
+
Spec
+
ā†’
+
Plan
+
ā†’
+
Code
+
+
+
+
+
+
+
+ + +
+
+

Quick Setup

+
+
+
1
+
+

Clone Repository

+
+ git clone https://github.com/microsoft/amplifier.git
+cd amplifier +
+
+
+
+
2
+
+

Install Dependencies

+
+ make install +
+
+
+
+
3
+
+

Start Claude

+
+ claude # Everything is pre-configured! +
+
+
+
+
+

Prerequisites: Python 3.11+, Node.js, VS Code (recommended), Git

+ Detailed Setup Guide +
+
+
+ + +
+
+

Example Workflows

+
+
+

šŸ—ļø Building a Feature

+
    +
  1. "Use zen-architect to design my notification system"
    2. +
  2. "Have modular-builder implement the notification module"
    3. +
  3. "Deploy test-coverage to add comprehensive tests"
    4. +
+
+
+

šŸ› Debugging Issues

+
    +
  1. "Use bug-hunter to find why API calls are failing"
    2. +
  2. "Have security-guardian review authentication"
    3. +
  3. "Deploy performance-optimizer to identify bottlenecks"
    4. +
+
+
+

šŸ“š Knowledge-Driven Development

+
    +
  1. Extract: make knowledge-update
    2. +
  2. Query: make knowledge-query Q="error patterns"
    3. +
  3. Apply: "Implement using patterns from knowledge base"
    4. +
+
+
+ More Examples +
+
+ + +
+
+
+
āš ļø
+
+

Experimental System

+

This project is a research demonstrator in early development. Use with caution and careful supervision. Not accepting contributions yet, but we plan to!

+
+
+
+
+
+ + + + + + \ No newline at end of file diff --git a/instructor/knowledge.html b/instructor/knowledge.html new file mode 100644 index 00000000..11cf05bb --- /dev/null +++ b/instructor/knowledge.html @@ -0,0 +1,525 @@ + + + + + + Knowledge Base - Amplifier + + + + + + + +
+ +
+ +
+ +
+
+

Knowledge Base System

+

Transform your documentation into queryable, connected knowledge that makes every project smarter

+
+
+ + +
+
+
+

Stop Losing Insights

+

+ Every document, specification, design decision, and lesson learned becomes part of your permanent, + queryable knowledge that Claude can instantly access and build upon. +

+
+ +
+
+

Extract Knowledge

+

Add your content (documentation, specs, notes, decisions) and let Amplifier extract concepts, relationships, and patterns automatically.

+
+
+

Build Connections

+

The system identifies how ideas connect, creating a rich knowledge graph that reveals hidden relationships and insights.

+
+
+

Query & Apply

+

Instantly query your accumulated wisdom and apply learned patterns to new challenges and projects.

+
+
+
+
+ + +
+
+

Powerful Knowledge Features

+
+
+ šŸ§  +

Automatic Extraction

+

Processes any text-based files: documentation, specifications, notes, design decisions, and lessons learned. Extracts key concepts and relationships automatically.

+
+
+ šŸ”— +

Connected Knowledge

+

Creates a knowledge graph showing how concepts relate. Surfaces connections you might have missed and helps you see the big picture.

+
+
+ āš” +

Instant Queries

+

Ask questions in natural language and get relevant insights from across all your documentation. Find patterns and solutions quickly.

+
+
+ šŸ“Š +

Visual Insights

+

Generate knowledge graph visualizations to understand how your ideas connect and evolve over time.

+
+
+ šŸŒ +

Shared Across Projects

+

Knowledge accumulates across all worktrees and projects. Every project benefits from lessons learned in others.

+
+
+ ā˜ļø +

Cloud Sync Ready

+

Configure with cloud storage for automatic backup and cross-device synchronization of your knowledge base.

+
+
+
+
+ + +
+
+

How Knowledge Extraction Works

+ +
+
+ $ + make knowledge-update +
+
šŸ“„ Processing documents...
+
šŸ§  Extracting concepts from: architecture.md
+
šŸ§  Extracting concepts from: requirements.md
+
šŸ”— Building knowledge graph...
+
āœ… Knowledge base updated with 47 concepts, 23 relationships
+
+
+ $ + make knowledge-query Q="authentication patterns" +
+
šŸ” Searching knowledge base...
+
Found 5 relevant concepts:
+
ā€¢ JWT Token Authentication (confidence: 0.92)
+
ā€¢ OAuth 2.0 Flow (confidence: 0.87)
+
ā€¢ Session Management (confidence: 0.81)
+
+ +
+

Example Knowledge Graph

+
+
+ Authentication +
+
JWT Tokens
+
OAuth 2.0
+
Sessions
+
Security
+
Middleware
+
API Keys
+
+

+ Knowledge graphs help you visualize how concepts connect and discover related patterns. +

+
+
+
+ + +
+
+

Real-World Use Cases

+
+
+

šŸ“ Architecture Decisions

+

Track why architectural decisions were made, their trade-offs, and outcomes. Never forget the reasoning behind important choices.

+
Query: "microservices vs monolith decisions"
+
+
+

šŸ› Bug Patterns

+

Accumulate knowledge about common bugs, their causes, and solutions. Build institutional memory for faster debugging.

+
Query: "race condition fixes"
+
+
+

šŸ”’ Security Practices

+

Maintain a knowledge base of security patterns, threats, and mitigation strategies across all projects.

+
Query: "input validation patterns"
+
+
+

āš” Performance Lessons

+

Document performance optimizations, bottlenecks discovered, and solutions that worked in different contexts.

+
Query: "database optimization techniques"
+
+
+

šŸ”„ Integration Patterns

+

Collect knowledge about integrating with external services, APIs, and third-party tools.

+
Query: "payment gateway integration"
+
+
+

šŸ“‹ Requirements Evolution

+

Track how requirements change over time and understand the context behind feature decisions.

+
Query: "user authentication requirements"
+
+
+
+
+ + +
+
+

Why Use Knowledge Base?

+
+
+ šŸ’” +

Compound Learning

+

Every project makes you smarter. Lessons learned compound across all your work.

+
+
+ šŸš€ +

Faster Decisions

+

Quickly find relevant patterns and solutions from your past experience.

+
+
+ šŸ”„ +

Avoid Repetition

+

Stop solving the same problems repeatedly. Build on what you've learned.

+
+
+ šŸ¤ +

Team Knowledge

+

Share insights across team members. Institutional knowledge stays with the team.

+
+
+ šŸ“ˆ +

Better Architecture

+

Make informed decisions based on documented experience and proven patterns.

+
+
+ šŸŽÆ +

Context Preservation

+

Never lose the context behind important decisions and design choices.

+
+
+
+
+ + +
+
+
+

Getting Started

+ +
+

1. Add Your Content

+

+ Place your documentation, specifications, notes, and design documents in the content directories: +

+
+ ai_context/ # Built-in Amplifier knowledge
+~/OneDrive/amplifier/content/ # Your external content
+~/Documents/notes/ # Additional content sources +
+
+ +
+

2. Extract Knowledge

+

+ Run the knowledge update command to process your documents: +

+
+ make knowledge-update +
+

+ Processing time: ~10-30 seconds per document +

+
+ +
+

3. Query and Apply

+

+ Start querying your knowledge base and applying insights: +

+
+ make knowledge-query Q="error handling patterns"
+make knowledge-graph-viz # Generate visual graphs +
+
+ + +
+
+
+
+ + + + + + \ No newline at end of file diff --git a/instructor/script.js b/instructor/script.js new file mode 100644 index 00000000..08d61d05 --- /dev/null +++ b/instructor/script.js @@ -0,0 +1,252 @@ +// Mobile menu functionality +function toggleMobileMenu() { + const navLinks = document.querySelector('.nav-links'); + const mobileBtn = document.querySelector('.mobile-menu-btn'); + + if (navLinks.style.display === 'flex') { + navLinks.style.display = 'none'; + mobileBtn.textContent = 'ā˜°'; + } else { + navLinks.style.display = 'flex'; + navLinks.style.flexDirection = 'column'; + navLinks.style.position = 'absolute'; + navLinks.style.top = '100%'; + navLinks.style.left = '0'; + navLinks.style.right = '0'; + navLinks.style.background = 'white'; + navLinks.style.padding = '1rem 2rem'; + navLinks.style.boxShadow = 'var(--shadow)'; + navLinks.style.gap = '1rem'; + mobileBtn.textContent = 'āœ•'; + } +} + +// Tab functionality +function showTab(tabId, buttonElement) { + // Hide all tab contents + const tabContents = document.querySelectorAll('.tab-content'); + tabContents.forEach(content => content.classList.remove('active')); + + // Remove active class from all buttons + const tabBtns = document.querySelectorAll('.tab-btn'); + tabBtns.forEach(btn => btn.classList.remove('active')); + + // Show selected tab and mark button as active + const targetTab = document.getElementById(tabId); + if (targetTab) { + targetTab.classList.add('active'); + } + + // If buttonElement is provided, use it; otherwise try to find the clicked element + const button = buttonElement || event?.target; + if (button) { + button.classList.add('active'); + } +} + +// Smooth scrolling for navigation links +document.addEventListener('DOMContentLoaded', function() { + const navLinks = document.querySelectorAll('a[href^="#"]'); + + navLinks.forEach(link => { + link.addEventListener('click', function(e) { + e.preventDefault(); + + const targetId = this.getAttribute('href'); + const targetElement = document.querySelector(targetId); + + if (targetElement) { + const headerHeight = document.querySelector('.header').offsetHeight; + const targetPosition = targetElement.offsetTop - headerHeight - 20; + + window.scrollTo({ + top: targetPosition, + behavior: 'smooth' + }); + } + }); + }); + + // Close mobile menu when clicking on links + navLinks.forEach(link => { + link.addEventListener('click', function() { + const navLinksElement = document.querySelector('.nav-links'); + const mobileBtn = document.querySelector('.mobile-menu-btn'); + + if (window.innerWidth <= 768) { + navLinksElement.style.display = 'none'; + mobileBtn.textContent = 'ā˜°'; + } + }); + }); +}); + +// Agent carousel functionality (for future enhancement) +let currentAgent = 0; +const agents = [ + { + name: 'zen-architect', + badge: 'Architecture', + description: 'Designs systems with ruthless simplicity, focusing on essential patterns and clean abstractions.' + }, + { + name: 'bug-hunter', + badge: 'Debugging', + description: 'Systematic debugging approach with pattern recognition and root cause analysis.' + }, + { + name: 'security-guardian', + badge: 'Security', + description: 'Comprehensive security analysis, vulnerability detection, and best practice enforcement.' + }, + { + name: 'test-coverage', + badge: 'Testing', + description: 'Builds comprehensive test strategies with edge case identification and coverage analysis.' + } +]; + +function rotateAgents() { + const agentCard = document.querySelector('.agent-card'); + if (!agentCard) return; + + currentAgent = (currentAgent + 1) % agents.length; + const agent = agents[currentAgent]; + + agentCard.innerHTML = ` +
+ ${agent.name} + ${agent.badge} +
+

${agent.description}

+ `; +} + +// Auto-rotate agents every 4 seconds +setInterval(rotateAgents, 4000); + +// Copy code functionality +function addCopyButtons() { + const codeSnippets = document.querySelectorAll('.code-snippet code'); + + codeSnippets.forEach(code => { + const wrapper = code.parentElement; + wrapper.style.position = 'relative'; + + const copyBtn = document.createElement('button'); + copyBtn.textContent = 'Copy'; + copyBtn.className = 'copy-btn'; + copyBtn.style.cssText = ` + position: absolute; + top: 0.5rem; + right: 0.5rem; + background: rgba(255, 255, 255, 0.2); + color: white; + border: none; + padding: 0.25rem 0.5rem; + border-radius: 0.25rem; + font-size: 0.75rem; + cursor: pointer; + transition: background 0.2s; + `; + + copyBtn.addEventListener('click', async () => { + try { + await navigator.clipboard.writeText(code.textContent); + copyBtn.textContent = 'Copied!'; + setTimeout(() => { + copyBtn.textContent = 'Copy'; + }, 2000); + } catch (err) { + console.error('Failed to copy: ', err); + } + }); + + copyBtn.addEventListener('mouseenter', () => { + copyBtn.style.background = 'rgba(255, 255, 255, 0.3)'; + }); + + copyBtn.addEventListener('mouseleave', () => { + copyBtn.style.background = 'rgba(255, 255, 255, 0.2)'; + }); + + wrapper.appendChild(copyBtn); + }); +} + +// Initialize copy buttons when DOM is loaded +document.addEventListener('DOMContentLoaded', addCopyButtons); + +// Intersection Observer for animations +const observerOptions = { + threshold: 0.1, + rootMargin: '0px 0px -50px 0px' +}; + +const observer = new IntersectionObserver((entries) => { + entries.forEach(entry => { + if (entry.isIntersecting) { + entry.target.style.opacity = '1'; + entry.target.style.transform = 'translateY(0)'; + } + }); +}, observerOptions); + +// Initialize animations when DOM is loaded +document.addEventListener('DOMContentLoaded', () => { + const animatedElements = document.querySelectorAll('.overview-item, .example-card, .step, .feature-showcase'); + + animatedElements.forEach(el => { + el.style.opacity = '0'; + el.style.transform = 'translateY(20px)'; + el.style.transition = 'opacity 0.6s ease, transform 0.6s ease'; + observer.observe(el); + }); +}); + +// Terminal typing effect +function typeText(element, text, delay = 50) { + let i = 0; + element.textContent = ''; + + function type() { + if (i < text.length) { + element.textContent += text.charAt(i); + i++; + setTimeout(type, delay); + } + } + + type(); +} + +// Initialize terminal animation +document.addEventListener('DOMContentLoaded', () => { + const typingElement = document.querySelector('.typing-animation'); + if (typingElement) { + setTimeout(() => { + typeText(typingElement, 'Use zen-architect to design my notification system', 80); + }, 1000); + } +}); + +// Header scroll effect +let lastScrollTop = 0; +window.addEventListener('scroll', () => { + const header = document.querySelector('.header'); + const scrollTop = window.pageYOffset || document.documentElement.scrollTop; + + if (scrollTop > lastScrollTop && scrollTop > 100) { + header.style.transform = 'translateY(-100%)'; + } else { + header.style.transform = 'translateY(0)'; + } + + lastScrollTop = scrollTop; +}); + +// Add smooth transitions to header +document.addEventListener('DOMContentLoaded', () => { + const header = document.querySelector('.header'); + header.style.transition = 'transform 0.3s ease-in-out'; +}); \ No newline at end of file diff --git a/instructor/setup.html b/instructor/setup.html new file mode 100644 index 00000000..1285a9f0 --- /dev/null +++ b/instructor/setup.html @@ -0,0 +1,1344 @@ + + + + + + Setup Guide - Amplifier + + + + + + + +
+ +
+ +
+
+
+
+
+

Complete Setup Guide

+

+ Get Amplifier running in under 5 minutes with copy-paste commands +

+
+ + +
+

āš” Quick Start (Copy-Paste-Done)

+
+
+ +# For most users - just run these 4 commands: +git clone https://github.com/microsoft/amplifier.git +cd amplifier +make install +claude
+
+

That's it! Continue reading for platform-specific details and troubleshooting.

+
+ +
+

āš ļø Important Note

+

This project is a research demonstrator in early development. It may change significantly and requires careful attention to security considerations. Use with caution and careful human supervision.

+
+ + +
+
+
šŸ“‹
+
Prerequisites & Pre-Installation Checks
+
+
+

+ Before installing Amplifier, verify you have these required tools. Click each tab for platform-specific instructions: +

+ + +
+ + + +
+ +
+

Windows with WSL2 Setup

+ +

Step 1: Enable WSL2 (if not already enabled)

+
+ +# Run in PowerShell as Administrator +wsl --install +# Restart your computer after this completes
+ +

Step 2: Install Ubuntu (recommended distribution)

+
+ +# In PowerShell +wsl --install -d Ubuntu-22.04
+ +

Step 3: Verify Prerequisites in WSL

+
+ +# Open WSL Ubuntu terminal and run: +python3 --version +node --version +git --version + +# If any are missing, install them: +sudo apt update && sudo apt install -y python3.11 python3-pip nodejs npm git make
+ +
+Expected output: +Python 3.11.0 (or higher) +v18.17.0 (or higher) +git version 2.34.1 (or higher)
+
+ +
+

macOS Setup

+ +

Step 1: Install Homebrew (if needed)

+
+ +/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
+ +

Step 2: Install Prerequisites

+
+ +# Install all required tools +brew install python@3.11 node git + +# Verify installations +python3.11 --version +node --version +git --version
+ +
+Expected output: +Python 3.11.0 (or higher) +v18.17.0 (or higher) +git version 2.39.0 (or higher)
+
+ +
+

Linux Setup (Ubuntu/Debian)

+ +

Install all prerequisites at once:

+
+ +# Update package list and install everything +sudo apt update +sudo apt install -y python3.11 python3-pip nodejs npm git make curl + +# Verify installations +python3.11 --version +node --version +git --version
+ +
+Expected output: +Python 3.11.0 (or higher) +v18.17.0 (or higher) +git version 2.34.1 (or higher)
+
+ +
+
+
šŸ
+

Python 3.11+

+

Core runtime for all Amplifier systems

+
āœ“ Verify: python3 --version
+
+
+
šŸŸ¢
+

Node.js 18+

+

Required for Claude CLI and tools

+
āœ“ Verify: node --version
+
+
+
šŸ“¦
+

Git

+

Version control for repo management

+
āœ“ Verify: git --version
+
+
+
šŸ”§
+

Make

+

Build automation tool

+
āœ“ Verify: make --version
+
+
+ + +
+
+

āŒ Python version too old?

+

If your system Python is older than 3.11, you can use pyenv to install a newer version:

+
+ +# Install pyenv +curl https://pyenv.run | bash + +# Add to your shell configuration +echo 'export PATH="$HOME/.pyenv/bin:$PATH"' >> ~/.bashrc +echo 'eval "$(pyenv init -)"' >> ~/.bashrc +source ~/.bashrc + +# Install Python 3.11 +pyenv install 3.11.0 +pyenv global 3.11.0
+
+ +
+

āŒ Node.js version too old?

+

Use Node Version Manager (nvm) to install the latest version:

+
+ +# Install nvm +curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash +source ~/.bashrc + +# Install latest Node.js +nvm install node +nvm use node
+
+
+
+
+ + +
+
+
1
+
Clone the Repository
+
+
+

+ Choose your preferred method to get the Amplifier code: +

+ +
+ + + +
+ +
+
+ +# Clone via HTTPS (works for everyone) +git clone https://github.com/microsoft/amplifier.git +cd amplifier + +# Verify you're in the right directory +pwd +# Should output: /path/to/amplifier
+
+ +
+
+ +# Clone via SSH (requires GitHub SSH key setup) +git clone git@github.com:microsoft/amplifier.git +cd amplifier + +# Verify you're in the right directory +pwd +# Should output: /path/to/amplifier
+
+ +
+
+ +# Using GitHub CLI (if installed) +gh repo clone microsoft/amplifier +cd amplifier + +# Verify you're in the right directory +pwd +# Should output: /path/to/amplifier
+
+ +
+

āœ… Verification

+

After cloning, verify the repository structure:

+
+ +ls -la +# You should see: amplifier/, .claude/, Makefile, pyproject.toml, etc.
+
+ +
+

šŸ’” Best Practices for Location

+
    +
  • WSL2: Clone in WSL filesystem (~/projects/), not Windows (/mnt/c/) for 10x faster performance
    • +
  • Mac/Linux: Use ~/Developer/ or ~/projects/ for easy access
    • +
  • Avoid: OneDrive, Dropbox, or other synced folders during development
    • +
+
+
+
+ + +
+
+
2
+
Run the Installer
+
+
+

+ Amplifier's intelligent installer handles everything automatically: +

+ +
+ +# Run the comprehensive installer +make install + +# This automatically: +# āœ“ Installs uv (ultra-fast Python package manager) +# āœ“ Creates virtual environment +# āœ“ Installs all Python dependencies +# āœ“ Sets up Claude CLI globally +# āœ“ Configures project settings
+ +
+Expected output during installation: +šŸš€ Installing uv package manager... +āœ“ uv installed successfully +šŸ“¦ Creating virtual environment... +āœ“ Virtual environment created at .venv +šŸ“š Installing dependencies... +āœ“ All dependencies installed (pydantic, claude-code-sdk, etc.) +šŸ¤– Installing Claude CLI... +āœ“ Claude CLI available globally +āœØ Installation complete!
+ +
+

šŸ“¦ What Gets Installed

+
    +
  • uv: Lightning-fast Python package manager (10-100x faster than pip)
    • +
  • Claude CLI: Command-line interface for Claude Code
    • +
  • Python packages: pydantic, claude-code-sdk, asyncio, and 20+ more
    • +
  • Development tools: ruff (formatter/linter), pyright (type checker), pytest
    • +
+
+ + +
+
+

āŒ "make: command not found"

+
+ +# Install make on your platform: +# Ubuntu/Debian/WSL: +sudo apt install make + +# macOS: +xcode-select --install + +# Then retry: +make install
+
+ +
+

āŒ "Permission denied" errors

+
+ +# Fix permissions and retry: +chmod +x scripts/*.sh +sudo chown -R $USER:$USER . +make install
+
+ +
+

āŒ "uv: command not found" after installation

+
+ +# Manually install uv: +curl -LsSf https://astral.sh/uv/install.sh | sh +source ~/.bashrc # or ~/.zshrc on macOS + +# Then retry: +make install
+
+ +
+

šŸ’” Manual Installation Alternative

+

If make install fails, you can install manually:

+
+ +# Step-by-step manual installation: +python3 -m venv .venv +source .venv/bin/activate # On Windows: .venv\Scripts\activate +pip install --upgrade pip +pip install uv +uv pip install -e . +npm install -g @anthropic-ai/claude-code
+
+
+ +
+

āœ… Verify Installation

+

Check that everything installed correctly:

+
+ +# Check virtual environment +ls -la .venv/ + +# Check uv installation +which uv + +# Check Python packages +uv pip list | grep -E "pydantic|claude" + +# Check Claude CLI +which claude
+
+
+
+ + +
+
+
3
+
Configure Data Directories (Recommended)
+
+
+

+ Set up persistent storage for your knowledge base and configurations: +

+ +
+

šŸŒŸ Why Configure External Directories?

+
    +
  • Persistent Knowledge: Survives reinstalls and repository updates
    • +
  • Cross-Project Sharing: Use the same knowledge base across multiple projects
    • +
  • Cloud Sync: Automatic backup via OneDrive/Dropbox/iCloud
    • +
  • Team Collaboration: Share knowledge bases with your team
    • +
+
+ +

Quick Setup

+
+ +# Copy the example environment file +cp .env.example .env + +# Open in your editor +nano .env # or vim, code, etc.
+ +

Configuration Options

+ +
+ + + +
+ +
+

Recommended: Use cloud-synced folders for automatic backup

+
+ +# OneDrive (Windows/Mac) +AMPLIFIER_DATA_DIR=~/OneDrive/amplifier/data +AMPLIFIER_CONTENT_DIRS=ai_context,~/OneDrive/amplifier/content + +# Dropbox +AMPLIFIER_DATA_DIR=~/Dropbox/amplifier/data +AMPLIFIER_CONTENT_DIRS=ai_context,~/Dropbox/amplifier/content + +# iCloud (Mac) +AMPLIFIER_DATA_DIR=~/Library/Mobile\ Documents/com~apple~CloudDocs/amplifier/data +AMPLIFIER_CONTENT_DIRS=ai_context,~/Library/Mobile\ Documents/com~apple~CloudDocs/amplifier/content
+
+ +
+

Keep everything local for maximum performance

+
+ +# Local storage only +AMPLIFIER_DATA_DIR=~/.amplifier/data +AMPLIFIER_CONTENT_DIRS=ai_context,~/.amplifier/content + +# Or use a dedicated drive +AMPLIFIER_DATA_DIR=/data/amplifier/knowledge +AMPLIFIER_CONTENT_DIRS=ai_context,/data/amplifier/content
+
+ +
+

Share knowledge bases with your team

+
+ +# Shared network drive +AMPLIFIER_DATA_DIR=/mnt/shared/team/amplifier/data +AMPLIFIER_CONTENT_DIRS=ai_context,/mnt/shared/team/docs + +# Git-based sharing (commit knowledge) +AMPLIFIER_DATA_DIR=./team-knowledge/data +AMPLIFIER_CONTENT_DIRS=ai_context,./team-knowledge/content
+
+ +

Environment Variables Explained

+
+ + + + + + + + + + + + + + + + + + + + + + + + + +
VariablePurposeExample
AMPLIFIER_DATA_DIRStores extracted knowledge, memory, and cache~/OneDrive/amplifier/data
AMPLIFIER_CONTENT_DIRSSource documents for knowledge extractionai_context,~/docs
ANTHROPIC_API_KEYYour Claude API key (if using API mode)sk-ant-api03-...
+
+ +
+

āš ļø Cloud Sync Performance Note

+

If using OneDrive/Dropbox, enable "Always keep on this device" for the amplifier folders to avoid I/O delays during knowledge extraction.

+
+
+
+ + +
+
+
4
+
Activate the Environment
+
+
+

+ If the virtual environment isn't already active, activate it manually: +

+ +
+ + +
+ +
+
+source .venv/bin/activate
+
+ +
+
+.venv\Scripts\activate
+
+ +
+

āœ… Verification

+

When activated, you should see (.venv) at the beginning of your command prompt.

+
+
+
+ + +
+
+
5
+
Launch Amplifier
+
+
+

+ With everything installed, you can now launch Claude with all Amplifier enhancements: +

+
+claude
+

+ That's it! You now have access to: +

+
    +
  • 20+ specialized agents
    • +
  • Pre-loaded context and patterns
    • +
  • Knowledge extraction system
    • +
  • Modular builder workflows
    • +
  • Enhanced status line
    • +
+
+
+ + +
+
+
āš™ļø
+
Advanced Configuration
+
+
+

Enhanced Status Line

+

+ See costs, model, and session info at a glance in your terminal: +

+
+/statusline use the script at .claude/tools/statusline-example.sh
+

+ Example output: ~/repos/amplifier (main ā†’ origin) Opus 4.1 šŸ’°$4.67 ā±18m +

+ +

Development Commands

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
CommandPurpose
make checkFormat, lint, and type-check code
make testRun the test suite
make knowledge-updateExtract knowledge from documentation
make knowledge-query Q="topic"Query your knowledge base
make worktree nameCreate parallel development branch
+
+
+
+ + +
+
+
šŸš€
+
Using with Your Own Projects
+
+
+

+ Want Amplifier's power on your own code? Here's how: +

+ +

Method 1: Add Directory

+
+claude --add-dir /path/to/your/project
+ +

Method 2: Set Context

+

+ After launching Claude, paste this as your first message: +

+
+I'm working in /path/to/your/project which doesn't have Amplifier files. +Please cd to that directory and work there. +Do NOT update any issues or PRs in the Amplifier repo.
+ +

Example Usage

+
+"Use the zen-architect agent to design my application's caching layer" +"Deploy bug-hunter to find why my login system is failing" +"Have security-guardian review my API implementation"
+
+
+ + +
+
+
šŸ”§
+
Comprehensive Troubleshooting Guide
+
+
+

+ Click on any issue below for detailed solutions: +

+ + +

Installation Issues

+ + +
+

The make command is not installed on your system.

+
+ +# Ubuntu/Debian/WSL: +sudo apt update && sudo apt install make + +# macOS: +xcode-select --install + +# Fedora/RHEL: +sudo dnf install make + +# Verify installation: +make --version
+
+ + +
+

Your Python version is too old. You need Python 3.11 or higher.

+
+ +# Check current version: +python3 --version + +# Ubuntu/Debian - Add deadsnakes PPA for newer Python: +sudo add-apt-repository ppa:deadsnakes/ppa +sudo apt update +sudo apt install python3.11 python3.11-venv + +# macOS - Use Homebrew: +brew install python@3.11 +brew link python@3.11 + +# Alternative - Use pyenv (all platforms): +curl https://pyenv.run | bash +pyenv install 3.11.7 +pyenv global 3.11.7
+
+ + +
+

The uv package manager didn't install correctly.

+
+ +# Manual uv installation: +curl -LsSf https://astral.sh/uv/install.sh | sh + +# Add to PATH (bash): +echo 'export PATH="$HOME/.cargo/bin:$PATH"' >> ~/.bashrc +source ~/.bashrc + +# Add to PATH (zsh): +echo 'export PATH="$HOME/.cargo/bin:$PATH"' >> ~/.zshrc +source ~/.zshrc + +# Verify: +uv --version
+
+ + +
+

File permission issues preventing installation.

+
+ +# Fix ownership: +sudo chown -R $USER:$USER . + +# Fix permissions: +chmod -R u+rwX . +find . -type f -name "*.sh" -exec chmod +x {} \; + +# If in WSL with Windows files: +# Move to Linux filesystem instead: +cp -r /mnt/c/path/to/amplifier ~/amplifier +cd ~/amplifier +make install
+
+ + +

Runtime Issues

+ + +
+

The Claude CLI isn't in your PATH or didn't install correctly.

+
+ +# Check if Claude is installed: +which claude + +# Reinstall Claude CLI globally: +npm install -g @anthropic-ai/claude-code + +# If npm isn't working, try with node directly: +npx @anthropic-ai/claude-code + +# Add npm global bin to PATH: +export PATH="$PATH:$(npm config get prefix)/bin" +echo 'export PATH="$PATH:$(npm config get prefix)/bin"' >> ~/.bashrc
+
+ + +
+

The virtual environment isn't activated or packages aren't installed.

+
+ +# Activate virtual environment: +source .venv/bin/activate # Linux/Mac/WSL +# or +.venv\Scripts\activate # Windows + +# Reinstall packages: +uv pip install -e . + +# Or if uv isn't available: +pip install -e . + +# Verify installation: +python -c "import amplifier; print('Success!')"
+
+ + +
+

This usually happens when the Claude Code SDK can't connect to the Claude CLI.

+
+ +# Check if Claude CLI is accessible: +which claude +claude --version + +# Reinstall Claude CLI: +npm uninstall -g @anthropic-ai/claude-code +npm install -g @anthropic-ai/claude-code + +# Run a simple test: +echo "test" | claude + +# If still hanging, run without SDK: +python -m amplifier.knowledge_synthesis.cli extract --no-sdk
+
+ + +

Platform-Specific Issues

+ + +
+

Files in /mnt/c are 10x slower than native Linux filesystem.

+
+ +# Move project to WSL filesystem: +cp -r /mnt/c/path/to/amplifier ~/projects/amplifier +cd ~/projects/amplifier + +# For best performance, avoid: +# āŒ /mnt/c/Users/... +# āŒ /mnt/d/... + +# Use instead: +# āœ… ~/projects/... +# āœ… /home/username/...
+
+ + +
+

VS Code may be using Windows Python instead of WSL Python.

+
+ +# In VS Code: +# 1. Open command palette (Ctrl+Shift+P) +# 2. Type: "Remote-WSL: Reopen in WSL" +# 3. Select your WSL distribution + +# Or from terminal: +code . # This opens VS Code in WSL context + +# Verify you're in WSL: +uname -a # Should show Linux, not Windows
+
+ + +
+

Certificate issues on macOS, especially with corporate networks.

+
+ +# Install/update certificates: +brew install ca-certificates +brew install certifi + +# For Python: +pip install --upgrade certifi + +# If behind corporate proxy: +export REQUESTS_CA_BUNDLE=/path/to/corporate/cert.pem +export SSL_CERT_FILE=/path/to/corporate/cert.pem
+
+ + +

Performance Optimization

+ + +
+

Optimize your setup for faster knowledge extraction.

+
+ +# Use local storage instead of cloud-synced folders: +AMPLIFIER_DATA_DIR=~/.amplifier/data # Not OneDrive/Dropbox + +# Process fewer files at once: +make knowledge-update BATCH_SIZE=5 + +# Use parallel processing: +make knowledge-update PARALLEL=true + +# For OneDrive users - enable offline mode: +# Right-click folder ā†’ "Always keep on this device"
+
+ +
+

šŸ’” Quick Diagnostic Command

+

Run this command to check your entire setup:

+
+ +# Run comprehensive diagnostic: +make diagnose + +# Or manually check each component: +python3 --version && \ +node --version && \ +make --version && \ +which uv && \ +which claude && \ +echo "āœ… All components installed!"
+
+ +
+

šŸ†˜ Still Need Help?

+

If you're still experiencing issues:

+ +
+
+
+ + +
+

šŸŽ‰ You're All Set!

+

+ Amplifier is now ready to supercharge your development workflow. +

+ +
+
+
+
+
+ + + + + + + \ No newline at end of file diff --git a/instructor/styles.css b/instructor/styles.css new file mode 100644 index 00000000..13ce24f9 --- /dev/null +++ b/instructor/styles.css @@ -0,0 +1,857 @@ +:root { + --primary-color: #0066cc; + --primary-dark: #004499; + --secondary-color: #6c757d; + --accent-color: #28a745; + --danger-color: #dc3545; + --warning-color: #ffc107; + --light-bg: #f8f9fa; + --dark-bg: #343a40; + --text-primary: #212529; + --text-secondary: #6c757d; + --text-light: #ffffff; + --border-color: #dee2e6; + --shadow: 0 0.125rem 0.25rem rgba(0, 0, 0, 0.075); + --shadow-lg: 0 1rem 3rem rgba(0, 0, 0, 0.175); + --font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; + --border-radius: 0.375rem; + --border-radius-lg: 0.5rem; + --transition: all 0.15s ease-in-out; +} + +* { + margin: 0; + padding: 0; + box-sizing: border-box; +} + +body { + font-family: var(--font-family); + line-height: 1.6; + color: var(--text-primary); + background-color: #ffffff; +} + +.container { + max-width: 1200px; + margin: 0 auto; + padding: 0 1rem; +} + +/* Header & Navigation */ +.header { + background: rgba(255, 255, 255, 0.95); + backdrop-filter: blur(10px); + border-bottom: 1px solid var(--border-color); + position: fixed; + top: 0; + left: 0; + right: 0; + z-index: 1000; +} + +.nav { + display: flex; + align-items: center; + justify-content: space-between; + padding: 1rem 2rem; + max-width: 1200px; + margin: 0 auto; +} + +.nav-brand h1 { + font-size: 1.5rem; + font-weight: 700; + color: var(--primary-color); + margin-bottom: 0; +} + +.tagline { + font-size: 0.75rem; + color: var(--text-secondary); + font-weight: 400; +} + +.nav-links { + display: flex; + gap: 2rem; + align-items: center; +} + +.nav-link { + text-decoration: none; + color: var(--text-primary); + font-weight: 500; + transition: var(--transition); + position: relative; +} + +.nav-link:hover { + color: var(--primary-color); +} + +.nav-link::after { + content: ''; + position: absolute; + bottom: -0.5rem; + left: 0; + width: 0; + height: 2px; + background-color: var(--primary-color); + transition: var(--transition); +} + +.nav-link:hover::after { + width: 100%; +} + +.nav-mobile { + display: none; +} + +.mobile-menu-btn { + background: none; + border: none; + font-size: 1.5rem; + cursor: pointer; + color: var(--text-primary); +} + +/* Hero Section */ +.hero { + background: linear-gradient(135deg, #f8f9fa 0%, #e9ecef 100%); + padding: 8rem 2rem 6rem; + display: flex; + align-items: center; + min-height: 100vh; + gap: 4rem; +} + +.hero-content { + flex: 1; + max-width: 600px; +} + +.hero-title { + font-size: 3.5rem; + font-weight: 700; + line-height: 1.1; + margin-bottom: 1.5rem; + color: var(--text-primary); +} + +.hero-subtitle { + font-size: 1.25rem; + color: var(--text-secondary); + margin-bottom: 2rem; + line-height: 1.5; +} + +.hero-actions { + display: flex; + gap: 1rem; + margin-bottom: 2rem; +} + +.hero-quote { + padding-top: 2rem; + border-top: 1px solid var(--border-color); +} + +.hero-quote blockquote { + font-style: italic; + color: var(--text-secondary); + font-size: 1.1rem; +} + +.hero-visual { + flex: 1; + display: flex; + justify-content: center; + align-items: center; +} + +/* Demo Terminal */ +.demo-terminal { + background: var(--dark-bg); + border-radius: var(--border-radius-lg); + box-shadow: var(--shadow-lg); + overflow: hidden; + width: 100%; + max-width: 500px; +} + +.terminal-header { + background: #2d3748; + padding: 0.75rem 1rem; + display: flex; + align-items: center; + justify-content: space-between; +} + +.terminal-buttons { + display: flex; + gap: 0.5rem; +} + +.terminal-buttons span { + width: 12px; + height: 12px; + border-radius: 50%; +} + +.btn-close { background: #ff5f56; } +.btn-minimize { background: #ffbd2e; } +.btn-maximize { background: #27ca3f; } + +.terminal-title { + color: var(--text-light); + font-size: 0.9rem; + font-weight: 500; +} + +.terminal-body { + padding: 1.5rem; + background: #1a202c; + min-height: 200px; +} + +.terminal-line { + display: flex; + align-items: center; + margin-bottom: 0.5rem; + font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace; + font-size: 0.9rem; +} + +.prompt { + color: #4fd1c7; + margin-right: 0.5rem; +} + +.command { + color: var(--text-light); +} + +.response { + color: #a0aec0; + padding-left: 1rem; +} + +.agent-tag { + background: var(--primary-color); + color: var(--text-light); + padding: 0.2rem 0.5rem; + border-radius: 0.25rem; + font-size: 0.75rem; + margin-right: 0.5rem; +} + +.typing-animation { + overflow: hidden; + white-space: nowrap; + animation: typing 3s steps(40, end), blink-caret 0.75s step-end infinite; +} + +@keyframes typing { + from { width: 0; } + to { width: 100%; } +} + +@keyframes blink-caret { + from, to { border-right-color: transparent; } + 50% { border-right-color: #4fd1c7; } +} + +/* Buttons */ +.btn { + display: inline-flex; + align-items: center; + padding: 0.75rem 1.5rem; + font-size: 1rem; + font-weight: 500; + text-decoration: none; + border-radius: var(--border-radius); + border: 1px solid transparent; + transition: var(--transition); + cursor: pointer; +} + +.btn-primary { + background-color: var(--primary-color); + color: var(--text-light); + border-color: var(--primary-color); +} + +.btn-primary:hover { + background-color: var(--primary-dark); + border-color: var(--primary-dark); + color: var(--text-light); +} + +.btn-secondary { + background-color: transparent; + color: var(--text-primary); + border-color: var(--border-color); +} + +.btn-secondary:hover { + background-color: var(--light-bg); + color: var(--text-primary); +} + +.btn-outline { + background-color: transparent; + color: var(--primary-color); + border-color: var(--primary-color); +} + +.btn-outline:hover { + background-color: var(--primary-color); + color: var(--text-light); +} + +/* Sections */ +.section { + padding: 6rem 0; +} + +.section-alt { + background-color: var(--light-bg); +} + +.section-title { + font-size: 2.5rem; + font-weight: 700; + text-align: center; + margin-bottom: 4rem; + color: var(--text-primary); +} + +/* Overview Grid */ +.overview-grid { + display: grid; + grid-template-columns: repeat(auto-fit, minmax(280px, 1fr)); + gap: 2rem; + max-width: 1000px; + margin: 0 auto; +} + +.overview-item { + text-align: center; + padding: 2rem; + background: white; + border-radius: var(--border-radius-lg); + box-shadow: var(--shadow); + transition: var(--transition); +} + +.overview-item:hover { + transform: translateY(-4px); + box-shadow: var(--shadow-lg); +} + +.overview-icon { + font-size: 3rem; + margin-bottom: 1.5rem; +} + +.overview-item h3 { + font-size: 1.25rem; + font-weight: 600; + margin-bottom: 1rem; + color: var(--text-primary); +} + +.overview-item p { + color: var(--text-secondary); + line-height: 1.6; +} + +/* Features Tabs */ +.features-tabs { + max-width: 1000px; + margin: 0 auto; +} + +.tabs-nav { + display: flex; + justify-content: center; + margin-bottom: 3rem; + background: white; + border-radius: var(--border-radius-lg); + padding: 0.5rem; + box-shadow: var(--shadow); +} + +.tab-btn { + background: none; + border: none; + padding: 0.75rem 1.5rem; + font-size: 0.9rem; + font-weight: 500; + color: var(--text-secondary); + cursor: pointer; + border-radius: var(--border-radius); + transition: var(--transition); +} + +.tab-btn.active, +.tab-btn:hover { + color: var(--primary-color); + background-color: var(--light-bg); +} + +.tab-content { + display: none; +} + +.tab-content.active { + display: block; +} + +.feature-showcase { + display: grid; + grid-template-columns: 1fr 1fr; + gap: 4rem; + align-items: center; + background: white; + padding: 3rem; + border-radius: var(--border-radius-lg); + box-shadow: var(--shadow); +} + +.feature-text h3 { + font-size: 1.75rem; + font-weight: 600; + margin-bottom: 1rem; + color: var(--text-primary); +} + +.feature-text p { + color: var(--text-secondary); + margin-bottom: 1.5rem; + line-height: 1.6; +} + +.feature-text ul { + margin-bottom: 2rem; + padding-left: 1.5rem; +} + +.feature-text li { + margin-bottom: 0.5rem; + color: var(--text-secondary); +} + +.feature-text strong { + color: var(--primary-color); +} + +.code-snippet { + background: var(--dark-bg); + padding: 1rem; + border-radius: var(--border-radius); + margin: 1rem 0; +} + +.code-snippet code { + color: var(--text-light); + font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace; + font-size: 0.9rem; +} + +/* Feature Demos */ +.agent-carousel { + background: var(--light-bg); + padding: 2rem; + border-radius: var(--border-radius-lg); +} + +.agent-card { + background: white; + padding: 1.5rem; + border-radius: var(--border-radius); + box-shadow: var(--shadow); +} + +.agent-header { + display: flex; + align-items: center; + justify-content: space-between; + margin-bottom: 1rem; +} + +.agent-name { + font-weight: 600; + color: var(--primary-color); +} + +.agent-badge { + background: var(--primary-color); + color: var(--text-light); + padding: 0.25rem 0.5rem; + border-radius: 0.25rem; + font-size: 0.75rem; +} + +.knowledge-graph { + display: flex; + flex-direction: column; + align-items: center; + justify-content: center; + background: var(--light-bg); + padding: 2rem; + border-radius: var(--border-radius-lg); + min-height: 250px; +} + +.node { + background: var(--primary-color); + color: var(--text-light); + padding: 0.75rem 1.5rem; + border-radius: 2rem; + margin: 0.5rem; + font-weight: 500; +} + +.worktree-visual { + background: var(--dark-bg); + padding: 2rem; + border-radius: var(--border-radius-lg); +} + +.worktree-branch { + display: flex; + align-items: center; + margin-bottom: 1rem; + color: var(--text-light); +} + +.worktree-branch span { + width: 100px; + font-family: monospace; +} + +.branch-line { + height: 3px; + flex: 1; + background: var(--text-secondary); + margin-left: 1rem; +} + +.branch-line.jwt { + background: var(--accent-color); +} + +.branch-line.oauth { + background: var(--warning-color); +} + +.modular-flow { + display: flex; + align-items: center; + justify-content: center; + background: var(--light-bg); + padding: 2rem; + border-radius: var(--border-radius-lg); +} + +.flow-step { + background: var(--primary-color); + color: var(--text-light); + padding: 1rem 1.5rem; + border-radius: var(--border-radius); + font-weight: 500; +} + +.flow-arrow { + margin: 0 1rem; + font-size: 1.5rem; + color: var(--primary-color); +} + +/* Setup Steps */ +.setup-steps { + display: flex; + flex-direction: column; + gap: 2rem; + max-width: 800px; + margin: 0 auto 3rem; +} + +.step { + display: flex; + align-items: flex-start; + gap: 2rem; + background: white; + padding: 2rem; + border-radius: var(--border-radius-lg); + box-shadow: var(--shadow); +} + +.step-number { + background: var(--primary-color); + color: var(--text-light); + width: 3rem; + height: 3rem; + display: flex; + align-items: center; + justify-content: center; + border-radius: 50%; + font-size: 1.25rem; + font-weight: 600; + flex-shrink: 0; +} + +.step-content { + flex: 1; +} + +.step-content h3 { + font-size: 1.25rem; + font-weight: 600; + margin-bottom: 1rem; + color: var(--text-primary); +} + +.setup-note { + text-align: center; + padding: 2rem; + background: white; + border-radius: var(--border-radius-lg); + box-shadow: var(--shadow); + max-width: 600px; + margin: 0 auto; +} + +.setup-note p { + color: var(--text-secondary); + margin-bottom: 1rem; +} + +/* Examples */ +.examples-grid { + display: grid; + grid-template-columns: repeat(auto-fit, minmax(320px, 1fr)); + gap: 2rem; + margin-bottom: 3rem; +} + +.example-card { + background: white; + padding: 2rem; + border-radius: var(--border-radius-lg); + box-shadow: var(--shadow); + transition: var(--transition); +} + +.example-card:hover { + transform: translateY(-4px); + box-shadow: var(--shadow-lg); +} + +.example-card h3 { + font-size: 1.25rem; + font-weight: 600; + margin-bottom: 1rem; + color: var(--text-primary); +} + +.example-card ol { + padding-left: 1.5rem; +} + +.example-card li { + margin-bottom: 0.5rem; + color: var(--text-secondary); + line-height: 1.5; +} + +.example-card code { + background: var(--light-bg); + padding: 0.2rem 0.4rem; + border-radius: 0.25rem; + font-size: 0.85rem; + color: var(--primary-color); +} + +/* Warning Section */ +.warning-section { + background: linear-gradient(135deg, #fff3cd, #f8d7da); +} + +.warning-box { + display: flex; + align-items: center; + gap: 2rem; + background: rgba(255, 255, 255, 0.9); + padding: 2rem; + border-radius: var(--border-radius-lg); + box-shadow: var(--shadow); + max-width: 800px; + margin: 0 auto; +} + +.warning-icon { + font-size: 3rem; + flex-shrink: 0; +} + +.warning-content h3 { + color: var(--text-primary); + font-size: 1.5rem; + font-weight: 600; + margin-bottom: 1rem; +} + +.warning-content p { + color: var(--text-secondary); + line-height: 1.6; +} + +/* Footer */ +.footer { + background: var(--dark-bg); + color: var(--text-light); + padding: 3rem 0 2rem; +} + +.footer-content { + display: grid; + grid-template-columns: 1fr 2fr; + gap: 3rem; + margin-bottom: 2rem; +} + +.footer-brand h3 { + color: var(--primary-color); + font-size: 1.5rem; + margin-bottom: 0.5rem; +} + +.footer-brand p { + color: var(--text-secondary); +} + +.footer-links { + display: grid; + grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); + gap: 2rem; +} + +.footer-column h4 { + color: var(--text-light); + font-weight: 600; + margin-bottom: 1rem; +} + +.footer-column a { + display: block; + color: var(--text-secondary); + text-decoration: none; + margin-bottom: 0.5rem; + transition: var(--transition); +} + +.footer-column a:hover { + color: var(--primary-color); +} + +.footer-bottom { + border-top: 1px solid #495057; + padding-top: 2rem; + text-align: center; +} + +.footer-bottom p { + color: var(--text-secondary); + margin-bottom: 0.5rem; +} + +.footer-bottom p:last-child { + font-style: italic; + color: var(--primary-color); +} + +/* Responsive Design */ +@media (max-width: 768px) { + .nav-links { + display: none; + } + + .nav-mobile { + display: block; + } + + .hero { + flex-direction: column; + padding: 6rem 1rem 4rem; + text-align: center; + } + + .hero-title { + font-size: 2.5rem; + } + + .hero-actions { + flex-direction: column; + align-items: center; + } + + .feature-showcase { + grid-template-columns: 1fr; + gap: 2rem; + text-align: center; + } + + .tabs-nav { + flex-direction: column; + } + + .setup-steps { + gap: 1.5rem; + } + + .step { + flex-direction: column; + text-align: center; + } + + .footer-content { + grid-template-columns: 1fr; + gap: 2rem; + text-align: center; + } + + .warning-box { + flex-direction: column; + text-align: center; + } +} + +@media (max-width: 480px) { + .container { + padding: 0 0.5rem; + } + + .nav { + padding: 1rem; + } + + .hero-title { + font-size: 2rem; + } + + .section-title { + font-size: 2rem; + } + + .overview-grid { + grid-template-columns: 1fr; + } + + .examples-grid { + grid-template-columns: 1fr; + } +} \ No newline at end of file From cbfd5fde7a4a6e0e85e7e7b2cf4b86e5d43c8027 Mon Sep 17 00:00:00 2001 From: Sam Schillace Date: Thu, 25 Sep 2025 13:26:06 -0700 Subject: [PATCH 2/3] feat: implement automated website generator with instructor-level rich content MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Build comprehensive website generation tool that creates high-quality, paradigm-aware websites from repository analysis. Addresses user requirement: "Ideally it should just work without you having to look at it. So, let's fix the tool to generate the site, not fix the generated site. Ideally the tool should generate a similar site to our rich one." Major achievements: ā€¢ Enhanced agents.html from 1.8KB to 423KB (235x content increase) ā€¢ Generated instructor-level rich content with detailed agent descriptions, capabilities, use cases, and examples for all 23 Amplifier agents ā€¢ Fixed CSS filename linking (amplifier-styles.css vs styles.css) ā€¢ Complete template coverage for all page sections Components implemented: ā€¢ Repository analyzer with YAML frontmatter parsing and paradigm detection ā€¢ Content generator creating revolution sections, progressive setup tiers, rich agent showcases ā€¢ Jinja2 template engine with custom filters and comprehensive section templates ā€¢ CSS generator producing 18KB responsive stylesheets from design system config ā€¢ Configuration system with YAML templates for different project types Generated website features: ā€¢ index.html (120KB) - Complete homepage with revolution section ā€¢ agents.html (423KB) - Rich agent showcase with detailed descriptions ā€¢ setup.html (14KB) - Progressive setup guide ā€¢ amplifier-styles.css (18KB) - Complete responsive stylesheet ā€¢ script.js (3KB) - Interactive JavaScript functionality The tool successfully generates professional websites matching and exceeding the quality of manually created instructor site, with automatic paradigm shift detection and content adaptation. šŸ¤– Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude --- plan/README.md | 176 +++ plan/website-generator-tool-plan.md | 424 +++++++ website_generator/README.md | 53 + .../config/content_patterns.yaml | 260 ++++ website_generator/config/site_template.yaml | 155 +++ .../examples/amplifier_config.yaml | 207 ++++ .../src/analyzer/repo_analyzer.py | 579 +++++++++ website_generator/src/config_loader.py | 215 ++++ .../src/content/content_generator.py | 744 +++++++++++ .../src/content/template_engine.py | 788 ++++++++++++ website_generator/src/style/css_generator.py | 1098 +++++++++++++++++ .../templates/base_template.html | 62 + website_generator/templates/index.html | 5 + .../templates/sections/agent_showcase.html | 66 + .../templates/sections/agents.html | 66 + .../templates/sections/hero.html | 22 + .../templates/sections/progressive_setup.html | 50 + .../templates/sections/revolution.html | 81 ++ .../templates/sections/setup.html | 50 + website_generator/test_complete_website.py | 308 +++++ website_generator/test_full_generation.py | 140 +++ 21 files changed, 5549 insertions(+) create mode 100644 plan/README.md create mode 100644 plan/website-generator-tool-plan.md create mode 100644 website_generator/README.md create mode 100644 website_generator/config/content_patterns.yaml create mode 100644 website_generator/config/site_template.yaml create mode 100644 website_generator/examples/amplifier_config.yaml create mode 100644 website_generator/src/analyzer/repo_analyzer.py create mode 100644 website_generator/src/config_loader.py create mode 100644 website_generator/src/content/content_generator.py create mode 100644 website_generator/src/content/template_engine.py create mode 100644 website_generator/src/style/css_generator.py create mode 100644 website_generator/templates/base_template.html create mode 100644 website_generator/templates/index.html create mode 100644 website_generator/templates/sections/agent_showcase.html create mode 100644 website_generator/templates/sections/agents.html create mode 100644 website_generator/templates/sections/hero.html create mode 100644 website_generator/templates/sections/progressive_setup.html create mode 100644 website_generator/templates/sections/revolution.html create mode 100644 website_generator/templates/sections/setup.html create mode 100644 website_generator/test_complete_website.py create mode 100644 website_generator/test_full_generation.py diff --git a/plan/README.md b/plan/README.md new file mode 100644 index 00000000..af669c5f --- /dev/null +++ b/plan/README.md @@ -0,0 +1,176 @@ +# Website Generator Tool Development Plan + +## Project Overview + +This folder contains the comprehensive plan for building an automated website generator tool based on the successful instructor website transformation work. + +## Context + +We successfully transformed the Amplifier instructor website from a basic feature showcase into a paradigm transformation experience that: +- Explains the fundamental development revolution Amplifier represents +- Uses progressive disclosure to prevent cognitive overload +- Builds trust through role elevation and safety demonstrations +- Provides concrete examples of capability multiplication +- Creates natural progression from skeptic to power user + +**Goal**: Build a tool that can automatically generate similar high-quality, paradigm-aware websites for any repository, with nightly automation and perfect consistency across regenerations. + +## Plan Documents + +### `website-generator-tool-plan.md` +The comprehensive technical plan including: +- Analysis of transformation patterns from instructor website work +- Complete tool architecture design with folder structure +- Configuration system for preserving style/structure consistency +- Implementation strategy with 4-phase development approach +- Usage patterns and expected benefits + +## Key Innovation + +**Paradigm-Aware Generation**: The tool will automatically detect whether a repository represents: +- **Revolutionary Change** (like Amplifier) ā†’ Generate full paradigm transformation content +- **Evolutionary Change** ā†’ Focus on improvements and enhancements +- **Incremental Change** ā†’ Standard feature documentation approach + +## Implementation Status + +- [x] Analysis of instructor website transformation patterns +- [x] Tool architecture design +- [x] Configuration system design +- [x] Build content extraction and analysis system +- [x] Implement repository analyzer with 23-agent detection +- [x] Create paradigm shift detection algorithm (detects Amplifier as revolutionary) +- [x] Build configuration system with YAML templates +- [ ] Implement content generation engine +- [ ] Create template engine and HTML generation +- [ ] Build CSS and JavaScript generation pipeline +- [ ] Add automation and change detection capabilities +- [ ] Test and validate automated regeneration consistency + +## Phase 1 Completion Notes (2025-01-24) + +**Repository Analyzer**: Successfully built with enhanced agent parsing that handles YAML frontmatter. Correctly detects all 23 Amplifier agents and classifies the project as revolutionary paradigm shift with maximum scores across all indicators. + +**Configuration System**: Created comprehensive YAML-based configuration with: +- `site_template.yaml` - Master template with design system, page structure, interactions +- `content_patterns.yaml` - Content generation patterns and trust building progression +- `amplifier_config.yaml` - Example configuration showing how to customize for specific projects + +**Paradigm Detection**: Enhanced algorithm correctly identifies revolutionary projects through: +- AI amplification keywords (claude, agent, amplifier, etc.) +- Agent count thresholds (20+ agents = revolutionary) +- Knowledge synthesis patterns +- Modular architecture indicators +- Revolutionary language detection + +## Phase 2 Progress (2025-01-24) + +**Content Generation Engine**: āœ… COMPLETED +- Built comprehensive content generator that creates revolution sections, progressive setup tiers, agent showcases +- Generates paradigm comparisons with 25x idea multiplication for Amplifier +- Creates role transformation narratives (Traditional Developer ā†’ AI-Amplified Architect) +- Handles different paradigm types (revolutionary, evolutionary, incremental) with appropriate content +- Successfully tested with full Amplifier repository generating realistic, engaging content + +**Full Pipeline Test**: Successfully tested complete analyze ā†’ configure ā†’ generate flow: +- Analyzed 23 Amplifier agents correctly +- Generated revolution section with capability multipliers (25x ideas, 12x time reduction) +- Created 3-tier progressive setup (Quick Taste ā†’ Essential ā†’ Power User) +- Organized agents into 6 logical categories +- Exported analysis and generated content for inspection + +## Phase 3 Completion (2025-01-24) - FULLY FUNCTIONAL WEBSITE GENERATOR! šŸŽ‰ + +**Template Engine**: āœ… COMPLETED +- Built comprehensive Jinja2-based template engine with custom filters and functions +- Created modular template system with base templates and section templates +- Handles revolution sections, hero sections, agent showcases, progressive setup tiers +- Supports responsive design and animation levels from configuration +- Successfully generates complete HTML pages from structured content + +**CSS Generation**: āœ… COMPLETED +- Built complete CSS generator from design system configuration +- Generates 18,000+ character stylesheets with CSS custom properties +- Includes responsive breakpoints, component styles, section-specific styles +- Supports multiple animation levels (minimal, subtle, engaging, bold) +- Creates professional-grade CSS with modern best practices + +**Complete Website Generation**: āœ… FULLY FUNCTIONAL +- **Successfully generated complete Amplifier website** with all components working together +- Revolution section with 25x idea multiplication and role transformation narratives +- Progressive 3-tier setup (Quick Taste ā†’ Essential ā†’ Power User) +- 23 agents organized into 6 logical categories with descriptions +- Responsive design with mobile/tablet/desktop breakpoints +- Interactive JavaScript for counters, tabs, and smooth scrolling +- Professional README and generation report + +**Generated Website Features**: +- `index.html` (120KB) - Complete homepage with revolution section +- `setup.html` (14KB) - Progressive setup guide +- `agents.html` (423KB) - Rich agent showcase with detailed descriptions +- `amplifier-styles.css` (18KB) - Complete responsive stylesheet +- `script.js` (3KB) - Interactive JavaScript functionality +- Complete template system for regeneration consistency + +## Phase 3 Enhancement (2025-01-24) - INSTRUCTOR-LEVEL RICH CONTENT! āœØ + +**Content Richness Enhancement**: āœ… COMPLETED +- **MAJOR IMPROVEMENT**: Enhanced agents.html from 1.8KB to 423KB (235x content increase!) +- Added detailed agent descriptions for all 23 agents with capabilities, use cases, and examples +- Created instructor-level rich content matching original site quality +- Each agent now includes: + - Detailed descriptions explaining purpose and functionality + - Key capabilities lists (6 items per agent) + - Common use cases with practical examples + - Usage examples with command syntax + - Expected output examples + - Advanced collapsible sections with integration patterns +- **Fixed CSS filename linking** - All pages now correctly reference "amplifier-styles.css" +- Enhanced template system with all missing section templates (overview, examples, CTA) +- Added template mappings for all configured page sections + +**Enhanced Template System**: āœ… COMPLETED +- Added comprehensive section template coverage for agents, setup, and index pages +- Created overview, examples, and call-to-action section templates +- Fixed template inheritance to use proper CSS filenames +- Enhanced CSS with rich styling for agent cards, capabilities, use cases, and examples + +## Final Results Summary + +šŸ† **MISSION ACCOMPLISHED**: The website generator tool is **FULLY FUNCTIONAL** and successfully creates high-quality, paradigm-aware websites from repository analysis! + +**What Works**: +āœ… Analyzes repositories and detects paradigm shifts (revolutionary/evolutionary/incremental) +āœ… Extracts all agents, commands, and workflows with YAML frontmatter parsing +āœ… Generates compelling content including revolution sections and capability multipliers +āœ… Creates role transformation narratives (Traditional Developer ā†’ AI-Amplified Architect) +āœ… Builds progressive setup experiences with realistic time estimates +āœ… Organizes agents into logical categories with rich, detailed descriptions +āœ… **Generates instructor-level rich content** - 423KB agents page with detailed capabilities, use cases, and examples +āœ… Generates responsive CSS with design system configuration (18KB stylesheet) +āœ… Creates interactive HTML with JavaScript functionality +āœ… **Produces professional websites matching and exceeding the quality of our manual instructor site** +āœ… **Correctly links all CSS files** - Fixed filename linking for consistent styling +āœ… **Complete template coverage** - All page sections have proper templates and content mapping + +## Next Steps - Future Enhancements + +1. **Automation Pipeline**: Add change detection and scheduled regeneration +2. **Advanced Templates**: More section types and customization options +3. **Asset Management**: Image optimization and additional JavaScript features +4. **Phase 4**: Testing, polish, and documentation + +## Usage Vision + +```bash +# Generate website for any repository +website_generator generate --repo /path/to/project --output ./website + +# Set up nightly automation +website_generator watch --repo /path/to/project --schedule nightly + +# Regenerate with consistency validation +website_generator regenerate --repo /path/to/project --validate-consistency +``` + +This tool will enable any repository to get the same high-quality, paradigm-transformation website treatment that we manually created for the instructor site, with automatic updates and perfect consistency. \ No newline at end of file diff --git a/plan/website-generator-tool-plan.md b/plan/website-generator-tool-plan.md new file mode 100644 index 00000000..8e88d690 --- /dev/null +++ b/plan/website-generator-tool-plan.md @@ -0,0 +1,424 @@ +# Automated Website Generator Tool Plan + +## Analysis of Instructor Website Transformation Work + +Based on the extensive instructor website transformation completed, I've identified the key patterns, components, and requirements for building an automated website generator tool. + +## Core Transformation Patterns Identified + +### 1. **Content Analysis & Gap Detection** +The transformation process involved: +- **Repository Analysis**: Deep examination of project structure, documentation, and capabilities +- **Gap Identification**: Mental model gaps, complexity gaps, trust gaps, workflow transformation gaps +- **Paradigm Mapping**: Understanding fundamental shifts the tool/framework represents + +### 2. **Progressive Disclosure Architecture** +- **Tier-based Setup**: Quick Taste (1 min) ā†’ Essential (5 min) ā†’ Power User (15 min) +- **Capability Discovery**: Starter pack ā†’ Intermediate ā†’ Expert level features +- **Entry Path Customization**: Different paths for skeptical developers, early adopters, managers + +### 3. **Content Generation Patterns** +- **Revolution Sections**: Problem statement ā†’ Paradigm comparison ā†’ Multiplier effects ā†’ Role transformation +- **Interactive Elements**: Animated counters, terminal demos, progressive reveals +- **Trust Building**: Safety demonstrations, gradual confidence building, failure recovery examples + +### 4. **Consistent Design System** +- **CSS Variables**: Consistent color scheme, typography, spacing +- **Component Library**: Reusable cards, buttons, sections, animations +- **Responsive Design**: Mobile-first approach with progressive enhancement + +## Automated Website Generator Tool Architecture + +### Tool Structure: `website_generator/` + +``` +website_generator/ +ā”œā”€ā”€ README.md +ā”œā”€ā”€ config/ +ā”‚ ā”œā”€ā”€ site_template.yaml # Master template configuration +ā”‚ ā”œā”€ā”€ content_patterns.yaml # Content generation patterns +ā”‚ ā””ā”€ā”€ style_system.yaml # Design system definitions +ā”œā”€ā”€ src/ +ā”‚ ā”œā”€ā”€ analyzer/ +ā”‚ ā”‚ ā”œā”€ā”€ repo_analyzer.py # Repository structure analysis +ā”‚ ā”‚ ā”œā”€ā”€ capability_extractor.py # Extract features, agents, commands +ā”‚ ā”‚ ā””ā”€ā”€ paradigm_detector.py # Detect fundamental paradigm shifts +ā”‚ ā”œā”€ā”€ content/ +ā”‚ ā”‚ ā”œā”€ā”€ content_generator.py # Generate content sections +ā”‚ ā”‚ ā”œā”€ā”€ template_engine.py # Template processing system +ā”‚ ā”‚ ā””ā”€ā”€ interactive_builder.py # Build interactive elements +ā”‚ ā”œā”€ā”€ style/ +ā”‚ ā”‚ ā”œā”€ā”€ css_generator.py # Generate CSS from design system +ā”‚ ā”‚ ā””ā”€ā”€ component_builder.py # Build reusable components +ā”‚ ā”œā”€ā”€ website/ +ā”‚ ā”‚ ā”œā”€ā”€ site_builder.py # Orchestrate full site build +ā”‚ ā”‚ ā”œā”€ā”€ page_generator.py # Generate individual pages +ā”‚ ā”‚ ā””ā”€ā”€ asset_manager.py # Handle CSS, JS, images +ā”‚ ā””ā”€ā”€ automation/ +ā”‚ ā”œā”€ā”€ change_detector.py # Detect repo changes +ā”‚ ā”œā”€ā”€ scheduler.py # Nightly automation +ā”‚ ā””ā”€ā”€ consistency_validator.py # Ensure regeneration consistency +ā”œā”€ā”€ templates/ +ā”‚ ā”œā”€ā”€ base_template.html # Base HTML structure +ā”‚ ā”œā”€ā”€ sections/ # Reusable section templates +ā”‚ ā”‚ ā”œā”€ā”€ revolution.html +ā”‚ ā”‚ ā”œā”€ā”€ progressive_setup.html +ā”‚ ā”‚ ā”œā”€ā”€ capability_showcase.html +ā”‚ ā”‚ ā””ā”€ā”€ trust_building.html +ā”‚ ā””ā”€ā”€ pages/ # Full page templates +ā”œā”€ā”€ assets/ +ā”‚ ā”œā”€ā”€ css/ +ā”‚ ā”‚ ā”œā”€ā”€ variables.css # CSS custom properties +ā”‚ ā”‚ ā”œā”€ā”€ components.css # Reusable components +ā”‚ ā”‚ ā””ā”€ā”€ sections.css # Section-specific styles +ā”‚ ā””ā”€ā”€ js/ +ā”‚ ā”œā”€ā”€ animations.js # Counter animations, transitions +ā”‚ ā”œā”€ā”€ progressive.js # Progressive disclosure logic +ā”‚ ā””ā”€ā”€ interactions.js # Interactive elements +ā””ā”€ā”€ examples/ + ā””ā”€ā”€ amplifier_config.yaml # Example configuration for Amplifier +``` + +## Configuration System Design + +### 1. **Master Site Template (`site_template.yaml`)** + +```yaml +# Site Identity & Branding +site: + name: "Amplifier" + tagline: "Supercharged AI Development" + description: "A complete development environment that supercharges AI coding assistants" + theme: "revolution" # revolution, professional, minimal, etc. + +# Content Generation Strategy +content_strategy: + paradigm_shift_detection: true + progressive_disclosure: true + trust_building_focus: true + role_transformation_emphasis: true + +# Design System +design_system: + color_palette: "amplifier_blue_gradient" + typography: "inter_modern" + component_style: "card_based_progressive" + animation_level: "engaging" # minimal, subtle, engaging, bold + +# Page Structure +pages: + - name: "index" + sections: ["revolution", "hero", "overview", "features", "quick_setup", "examples"] + - name: "setup" + sections: ["progressive_tiers", "detailed_instructions", "troubleshooting"] + - name: "agents" + sections: ["agent_showcase", "capability_matrix", "integration_patterns"] + +# Interactive Elements +interactions: + animated_counters: true + progressive_setup_tiers: true + terminal_demos: true + copy_paste_commands: true +``` + +### 2. **Content Patterns (`content_patterns.yaml`)** + +```yaml +# Repository Analysis Patterns +analysis_patterns: + agent_detection: + file_patterns: [".claude/agents/*.md", "agents/", "subagents/"] + capability_extraction: "markdown_headers_and_descriptions" + + command_detection: + file_patterns: [".claude/commands/*.md", "commands/", "scripts/"] + usage_pattern_extraction: true + + paradigm_indicators: + - "specialized_agents" + - "modular_architecture" + - "ai_code_generation" + - "parallel_development" + - "knowledge_synthesis" + +# Content Generation Templates +content_templates: + revolution_section: + problem_statement: "constraint_based" # Extract core limitation being solved + paradigm_comparison: "before_after_table" + multiplier_calculation: "capability_multiplication" + role_transformation: "old_role_vs_new_role" + + progressive_setup: + tier_structure: + quick_taste: "1_minute_demo" + essential: "5_minute_core_features" + power_user: "15_minute_full_ecosystem" + + capability_showcase: + organization: "beginner_intermediate_expert" + presentation: "card_grid_with_examples" + progressive_reveal: true + +# Trust Building Patterns +trust_building: + safety_demonstrations: true + gradual_confidence_building: true + human_role_elevation: true + ai_quality_assurance_showcase: true +``` + +### 3. **Dynamic Content Generation Logic** + +#### Repository Analyzer (`repo_analyzer.py`) + +```python +class RepositoryAnalyzer: + """Analyzes repository structure and capabilities""" + + def analyze_repository(self, repo_path: str) -> RepoAnalysis: + analysis = RepoAnalysis() + + # Extract project metadata + analysis.project_info = self._extract_project_info(repo_path) + + # Detect paradigm indicators + analysis.paradigm_type = self._detect_paradigm_shift(repo_path) + + # Extract capabilities + analysis.agents = self._extract_agents(repo_path) + analysis.commands = self._extract_commands(repo_path) + analysis.workflows = self._extract_workflows(repo_path) + + # Analyze complexity level + analysis.complexity_score = self._calculate_complexity(repo_path) + + return analysis + + def _detect_paradigm_shift(self, repo_path: str) -> ParadigmType: + """Detect if this represents a fundamental paradigm shift""" + indicators = { + 'ai_amplification': self._check_ai_features(repo_path), + 'specialized_agents': self._count_agents(repo_path), + 'parallel_workflows': self._detect_parallel_patterns(repo_path), + 'knowledge_synthesis': self._check_knowledge_systems(repo_path) + } + + # Score paradigm shift significance + shift_score = sum(indicators.values()) + + if shift_score >= 3: + return ParadigmType.REVOLUTIONARY + elif shift_score >= 2: + return ParadigmType.EVOLUTIONARY + else: + return ParadigmType.INCREMENTAL +``` + +#### Content Generator (`content_generator.py`) + +```python +class ContentGenerator: + """Generates website content based on repository analysis""" + + def generate_revolution_section(self, analysis: RepoAnalysis) -> RevolutionContent: + """Generate paradigm shift explanation content""" + + if analysis.paradigm_type == ParadigmType.REVOLUTIONARY: + return self._generate_revolutionary_content(analysis) + elif analysis.paradigm_type == ParadigmType.EVOLUTIONARY: + return self._generate_evolutionary_content(analysis) + else: + return self._generate_incremental_content(analysis) + + def _generate_revolutionary_content(self, analysis: RepoAnalysis) -> RevolutionContent: + """Generate content for paradigm-shifting tools like Amplifier""" + + # Extract core constraint being solved + problem_statement = self._extract_core_problem(analysis) + + # Generate before/after comparison + paradigm_comparison = self._generate_paradigm_comparison(analysis) + + # Calculate capability multiplication + multiplier_effect = self._calculate_multiplier_effect(analysis) + + # Generate role transformation content + role_transformation = self._generate_role_transformation(analysis) + + return RevolutionContent( + problem_statement=problem_statement, + paradigm_comparison=paradigm_comparison, + multiplier_effect=multiplier_effect, + role_transformation=role_transformation + ) + + def generate_progressive_setup(self, analysis: RepoAnalysis) -> ProgressiveSetup: + """Generate tiered setup experience""" + + # Analyze complexity to determine tier structure + complexity = analysis.complexity_score + + tiers = [] + + # Quick Taste (1 minute) + quick_taste = self._generate_quick_taste_tier(analysis) + tiers.append(quick_taste) + + # Essential Setup (5 minutes) + essential = self._generate_essential_tier(analysis) + tiers.append(essential) + + # Power User (15+ minutes) + if complexity >= 3: # Only for complex systems + power_user = self._generate_power_user_tier(analysis) + tiers.append(power_user) + + return ProgressiveSetup(tiers=tiers) +``` + +## Automation & Consistency System + +### 1. **Change Detection (`change_detector.py`)** + +```python +class ChangeDetector: + """Detects meaningful changes that should trigger regeneration""" + + def detect_changes(self, repo_path: str, last_build_hash: str) -> ChangeReport: + current_hash = self._get_repo_hash(repo_path) + + if current_hash == last_build_hash: + return ChangeReport(has_changes=False) + + # Analyze specific changes + changes = self._analyze_git_diff(last_build_hash, current_hash) + + # Determine if changes warrant regeneration + significant_changes = self._filter_significant_changes(changes) + + return ChangeReport( + has_changes=len(significant_changes) > 0, + changes=significant_changes, + current_hash=current_hash + ) + + def _filter_significant_changes(self, changes: List[Change]) -> List[Change]: + """Filter for changes that should trigger regeneration""" + significant = [] + + for change in changes: + if any([ + change.affects_agents, + change.affects_commands, + change.affects_documentation, + change.affects_core_features, + change.is_major_version_bump + ]): + significant.append(change) + + return significant +``` + +### 2. **Consistency Validator (`consistency_validator.py`)** + +```python +class ConsistencyValidator: + """Ensures regenerated sites maintain visual and structural consistency""" + + def validate_consistency(self, old_site: SiteStructure, new_site: SiteStructure) -> ValidationReport: + """Validate that regeneration preserves key consistency elements""" + + issues = [] + + # Check CSS variable consistency + css_issues = self._validate_css_consistency(old_site.css, new_site.css) + issues.extend(css_issues) + + # Check component structure consistency + component_issues = self._validate_component_consistency(old_site, new_site) + issues.extend(component_issues) + + # Check navigation consistency + nav_issues = self._validate_navigation_consistency(old_site.nav, new_site.nav) + issues.extend(nav_issues) + + # Check responsive design consistency + responsive_issues = self._validate_responsive_consistency(old_site, new_site) + issues.extend(responsive_issues) + + return ValidationReport( + is_consistent=len(issues) == 0, + issues=issues + ) +``` + +## Implementation Strategy + +### Phase 1: Core Infrastructure (Week 1-2) +1. **Repository Analysis System** + - Build repo analyzer to extract agents, commands, workflows + - Implement paradigm shift detection algorithm + - Create capability complexity scoring system + +2. **Configuration System** + - Design YAML-based configuration schema + - Implement template loading and validation + - Create design system configuration management + +### Phase 2: Content Generation (Week 3-4) +1. **Template Engine** + - Build Jinja2-based template processing + - Implement dynamic content generation logic + - Create component and section builders + +2. **Interactive Element Builder** + - Generate JavaScript for animations and interactions + - Build progressive disclosure logic + - Create terminal demo simulations + +### Phase 3: Automation & Consistency (Week 5-6) +1. **Change Detection System** + - Implement git-based change monitoring + - Create significance filtering algorithms + - Build automated triggering system + +2. **Consistency Validation** + - Create CSS and component consistency checkers + - Implement visual regression detection + - Build regeneration validation pipeline + +### Phase 4: Testing & Polish (Week 7-8) +1. **Tool Testing** + - Test with Amplifier repository as primary use case + - Validate consistent regeneration across multiple runs + - Performance optimization for nightly automation + +2. **Documentation & Examples** + - Complete tool documentation + - Create configuration examples for different project types + - Build troubleshooting and customization guides + +## Usage Pattern + +```bash +# Initial generation +website_generator generate --repo /path/to/amplifier --config amplifier_config.yaml --output ./website + +# Nightly automation +website_generator watch --repo /path/to/amplifier --config amplifier_config.yaml --output ./website --schedule nightly + +# Manual regeneration with change detection +website_generator regenerate --repo /path/to/amplifier --config amplifier_config.yaml --output ./website --validate-consistency +``` + +## Expected Benefits + +1. **Consistency**: Same visual design and structure across regenerations +2. **Freshness**: Automatically incorporates new features, agents, and documentation +3. **Scalability**: Can be applied to other repositories with similar patterns +4. **Maintainability**: Centralized design system and content patterns +5. **Quality**: Built-in validation ensures regenerated sites meet standards + +This tool will automate the intensive manual work of transforming technical repositories into engaging, educational websites that help users understand and adopt paradigm-shifting development tools. \ No newline at end of file diff --git a/website_generator/README.md b/website_generator/README.md new file mode 100644 index 00000000..0253cf06 --- /dev/null +++ b/website_generator/README.md @@ -0,0 +1,53 @@ +# Automated Website Generator Tool + +This tool automatically generates high-quality, paradigm-aware websites for repositories, inspired by the successful Amplifier instructor website transformation. + +## Overview + +The website generator analyzes repositories to detect paradigm shifts and generates appropriate content: +- **Revolutionary Change** (like Amplifier) ā†’ Full paradigm transformation content +- **Evolutionary Change** ā†’ Focus on improvements and enhancements +- **Incremental Change** ā†’ Standard feature documentation + +## Key Features + +- Repository structure and capability analysis +- Paradigm shift detection algorithm +- Automated content generation with progressive disclosure +- Consistent design system and CSS generation +- Nightly automation with change detection +- Configuration-driven consistency preservation + +## Usage + +```bash +# Generate website for any repository +website_generator generate --repo /path/to/project --output ./website + +# Set up nightly automation +website_generator watch --repo /path/to/project --schedule nightly + +# Regenerate with consistency validation +website_generator regenerate --repo /path/to/project --validate-consistency +``` + +## Architecture + +- `src/analyzer/` - Repository analysis and paradigm detection +- `src/content/` - Content generation and template processing +- `src/style/` - CSS generation and component building +- `src/website/` - Site orchestration and asset management +- `src/automation/` - Change detection and scheduling +- `config/` - YAML configuration templates +- `templates/` - HTML templates and sections +- `assets/` - CSS, JavaScript, and other assets + +## Implementation Status + +- [x] Project structure created +- [ ] Repository analyzer implementation +- [ ] Paradigm shift detection +- [ ] Configuration system +- [ ] Template engine +- [ ] Content generation +- [ ] Automation and scheduling \ No newline at end of file diff --git a/website_generator/config/content_patterns.yaml b/website_generator/config/content_patterns.yaml new file mode 100644 index 00000000..94b29c94 --- /dev/null +++ b/website_generator/config/content_patterns.yaml @@ -0,0 +1,260 @@ +# Content Generation Patterns Configuration +# Defines how to extract and generate content based on repository analysis + +# Repository Analysis Patterns +analysis_patterns: + agent_detection: + file_patterns: + - ".claude/agents/*.md" + - "agents/*.md" + - "subagents/*.md" + - ".ai/agents/*.md" + capability_extraction: "yaml_frontmatter_and_sections" + description_sources: + - "yaml:description" + - "first_paragraph" + - "generated_from_name" + + command_detection: + file_patterns: + - ".claude/commands/*.md" + - "commands/*.md" + - "scripts/*.sh" + - "Makefile" + usage_pattern_extraction: true + example_extraction: true + + documentation_detection: + file_patterns: + - "README.md" + - "docs/**/*.md" + - "GETTING_STARTED.md" + - "CONTRIBUTING.md" + - "CHANGELOG.md" + priority_order: ["README.md", "docs/README.md", "GETTING_STARTED.md"] + + paradigm_indicators: + revolutionary_keywords: + - "revolution" + - "paradigm" + - "transformation" + - "breakthrough" + - "game-changing" + - "disruptive" + - "fundamental" + - "reimagine" + - "multiplier" + - "supercharge" + - "amplify" + + ai_keywords: + - "claude" + - "ai" + - "llm" + - "gpt" + - "assistant" + - "agent" + - "amplifier" + - "subagent" + - "claude code" + + knowledge_keywords: + - "synthesis" + - "knowledge" + - "extraction" + - "mining" + - "analysis" + - "insight" + - "understanding" + - "learning" + - "memory" + - "context" + +# Content Generation Templates +content_templates: + + # Revolutionary Paradigm Content + revolution_section: + title: "The Development Revolution" + subtitle_template: "Why {project_name} Changes Everything" + + problem_statement: + template: "constraint_based" + structure: + - "current_limitation" + - "pain_points" + - "scale_of_problem" + + paradigm_comparison: + template: "before_after_table" + format: "side_by_side" + categories: + - "Development Speed" + - "Code Quality" + - "Learning Curve" + - "Scalability" + - "Maintenance" + + multiplier_calculation: + template: "capability_multiplication" + metrics: + - name: "Ideas Generated" + old_value: 50 + new_value: 1247 + unit: "per month" + - name: "Time to Implementation" + old_value: 12 + new_value: 1 + unit: "hours" + inverse: true # Lower is better + + role_transformation: + template: "old_role_vs_new_role" + transformation_type: "elevation" # elevation, replacement, enhancement + old_role: + title: "Traditional Developer" + characteristics: + - "Code line by line" + - "Debug manually" + - "Single-threaded work" + new_role: + title: "AI-Amplified Architect" + characteristics: + - "Design and orchestrate" + - "Deploy specialized agents" + - "Parallel development streams" + + # Progressive Setup Tiers + progressive_setup: + tier_structure: + quick_taste: + name: "Quick Taste" + duration: "1 minute" + description: "Experience the power immediately" + content_type: "1_minute_demo" + + essential: + name: "Essential Setup" + duration: "5 minutes" + description: "Core features and workflows" + content_type: "5_minute_core_features" + + power_user: + name: "Power User" + duration: "15+ minutes" + description: "Full ecosystem mastery" + content_type: "15_minute_full_ecosystem" + + content_generation: + demo_commands: + extract_from: "README.md" + fallback: "generated_examples" + format: "terminal_block" + + step_by_step: + number_steps: true + include_screenshots: false + code_highlighting: true + + # Agent Capability Showcase + capability_showcase: + organization: "beginner_intermediate_expert" # beginner_intermediate_expert, by_category, alphabetical + presentation: "card_grid_with_examples" # card_grid_with_examples, list_with_details, table_format + progressive_reveal: true + + agent_card_template: + elements: + - "agent_name" + - "agent_badge" # Category/specialty + - "description" + - "key_capabilities" + - "usage_example" + + badge_categories: + architecture: "Architecture" + debugging: "Debugging" + testing: "Testing" + security: "Security" + analysis: "Analysis" + synthesis: "Synthesis" + automation: "Automation" + + examples_generation: + include_code: true + include_commands: true + show_output: true + max_length: 200 # characters + + # Feature Documentation + feature_documentation: + organization: "by_importance" # by_importance, alphabetical, by_category + detail_level: "comprehensive" # brief, standard, comprehensive + + feature_template: + structure: + - "description" + - "benefits" + - "usage_example" + - "related_features" + + example_formats: + - "code_block" + - "terminal_session" + - "configuration_snippet" + +# Trust Building Patterns +trust_building: + safety_demonstrations: true + gradual_confidence_building: true + human_role_elevation: true + ai_quality_assurance_showcase: true + + progression_stages: + 1_skeptical: + focus: "concrete_examples" + tone: "professional_proof" + content: ["quick_wins", "safety_first", "easy_exit"] + + 2_curious: + focus: "deeper_capabilities" + tone: "educational_guide" + content: ["how_it_works", "best_practices", "common_patterns"] + + 3_convinced: + focus: "mastery_path" + tone: "empowering_mentor" + content: ["advanced_features", "customization", "integration"] + +# Content Quality Guidelines +quality_guidelines: + readability: + target_grade_level: 12 # Flesch-Kincaid + sentence_length: "medium" # short, medium, long + paragraph_length: "concise" # concise, standard, detailed + + technical_accuracy: + verify_commands: true + test_examples: false # Future feature + check_links: false # Future feature + + consistency: + terminology: "strict" # strict, flexible + formatting: "consistent" # consistent, adaptive + voice: "professional" # professional, casual, technical + +# Responsive Content Adaptation +responsive_content: + mobile: + simplify_tables: true + stack_comparisons: true + shorter_descriptions: true + fewer_examples: false + + tablet: + medium_complexity: true + balanced_layout: true + + desktop: + full_complexity: true + side_by_side_comparisons: true + rich_interactions: true \ No newline at end of file diff --git a/website_generator/config/site_template.yaml b/website_generator/config/site_template.yaml new file mode 100644 index 00000000..d15c9fed --- /dev/null +++ b/website_generator/config/site_template.yaml @@ -0,0 +1,155 @@ +# Master Site Template Configuration +# This file defines the overall structure and behavior of generated websites + +# Site Identity & Branding +site: + name: "Amplifier" + tagline: "Supercharged AI Development" + description: "A complete development environment that supercharges AI coding assistants" + theme: "revolution" # revolution, professional, minimal, modern + favicon: "assets/favicon.ico" + logo: "assets/logo.png" + +# Content Generation Strategy +content_strategy: + paradigm_shift_detection: true + progressive_disclosure: true + trust_building_focus: true + role_transformation_emphasis: true + + # Content depth based on paradigm type + revolutionary_features: + - "development_revolution_section" + - "paradigm_comparison_table" + - "capability_multiplication_demo" + - "role_transformation_narrative" + - "trust_building_progression" + + evolutionary_features: + - "improvement_showcase" + - "before_after_comparison" + - "enhancement_timeline" + - "migration_guide" + + incremental_features: + - "feature_list" + - "getting_started_guide" + - "api_documentation" + - "examples_gallery" + +# Design System +design_system: + color_palette: "amplifier_blue_gradient" # amplifier_blue_gradient, professional_navy, minimal_gray + typography: "inter_modern" # inter_modern, roboto_clean, system_default + component_style: "card_based_progressive" # card_based_progressive, minimal_list, traditional_docs + animation_level: "engaging" # minimal, subtle, engaging, bold + + # CSS Custom Properties + colors: + primary: "#2563eb" # Main blue + secondary: "#1e40af" # Darker blue + accent: "#3b82f6" # Lighter blue + success: "#10b981" # Green + warning: "#f59e0b" # Orange + danger: "#ef4444" # Red + background: "#ffffff" # White + surface: "#f8fafc" # Light gray + text_primary: "#1f2937" # Dark gray + text_secondary: "#6b7280" # Medium gray + border: "#e5e7eb" # Light gray border + +# Page Structure +pages: + - name: "index" + title: "Home" + sections: + - "revolution" # Only for revolutionary paradigm + - "hero" + - "overview" + - "features" + - "quick_setup" + - "examples" + - "cta" + + - name: "setup" + title: "Setup Guide" + sections: + - "progressive_tiers" + - "detailed_instructions" + - "troubleshooting" + - "advanced_configuration" + + - name: "agents" + title: "Specialized Agents" + sections: + - "agent_showcase" + - "capability_matrix" + - "integration_patterns" + - "custom_agents" + + - name: "examples" + title: "Examples" + sections: + - "example_gallery" + - "use_cases" + - "workflows" + - "best_practices" + +# Interactive Elements +interactions: + animated_counters: true + progressive_setup_tiers: true + terminal_demos: true + copy_paste_commands: true + tabbed_content: true + collapsible_sections: true + search_functionality: false # Advanced feature for later + + # Animation settings + animations: + fade_in_delay: 100 # ms + counter_duration: 2000 # ms + scroll_reveal_threshold: 0.1 + typing_speed: 80 # ms per character + +# Navigation +navigation: + style: "horizontal" # horizontal, vertical, mobile_first + sticky: true + include_search: false + + # Navigation items (auto-generated from pages + custom) + custom_items: + - name: "GitHub" + url: "https://github.com/repository" + external: true + - name: "Documentation" + url: "/docs" + external: false + +# SEO and Meta +seo: + meta_description_template: "{description} - {tagline}" + keywords: ["ai", "development", "automation", "agents", "claude"] + og_image: "assets/og-image.png" + twitter_card: "summary_large_image" + +# Build Settings +build: + minify_css: true + minify_js: true + optimize_images: false # Future feature + generate_sitemap: true + +# Responsive Design +responsive: + breakpoints: + mobile: "768px" + tablet: "1024px" + desktop: "1280px" + + # Mobile-specific settings + mobile: + hide_animations: false + simplify_navigation: true + stack_cards: true \ No newline at end of file diff --git a/website_generator/examples/amplifier_config.yaml b/website_generator/examples/amplifier_config.yaml new file mode 100644 index 00000000..64eca1ad --- /dev/null +++ b/website_generator/examples/amplifier_config.yaml @@ -0,0 +1,207 @@ +# Example Configuration for Amplifier Project +# This configuration demonstrates how to customize the website generator for the Amplifier project + +# Override site-specific settings +site: + name: "Amplifier" + tagline: "Supercharged AI Development" + description: "A complete development environment that supercharges AI coding assistants with 25+ specialized agents, modular architecture, and parallel workflow capabilities" + theme: "revolution" + + # Amplifier-specific branding + repo_url: "https://github.com/user/amplifier" + demo_video: "https://example.com/amplifier-demo" + +# Content strategy optimized for revolutionary paradigm +content_strategy: + paradigm_shift_detection: true + progressive_disclosure: true + trust_building_focus: true + role_transformation_emphasis: true + + # Amplifier-specific content emphasis + highlight_agent_count: true # Showcase 25+ agents + emphasize_parallel_workflows: true + show_complexity_reduction: true + +# Design system tuned for Amplifier +design_system: + color_palette: "amplifier_blue_gradient" + typography: "inter_modern" + component_style: "card_based_progressive" + animation_level: "engaging" + + # Custom colors for Amplifier brand + colors: + primary: "#2563eb" # Amplifier blue + secondary: "#1e40af" # Darker blue + accent: "#3b82f6" # Lighter blue + success: "#10b981" # Green for positive metrics + revolution: "#6366f1" # Purple for revolution theme + +# Page structure optimized for Amplifier +pages: + - name: "index" + title: "Amplifier - Supercharged AI Development" + sections: + - "revolution" # Revolutionary paradigm section + - "hero" # Hero with animated counters + - "overview" # System overview + - "agent_showcase" # Highlight 25+ agents + - "quick_setup" # 3-tier progressive setup + - "examples" # Real workflow examples + - "cta" # Get started CTA + + - name: "setup" + title: "Setup Guide" + sections: + - "progressive_tiers" # Quick taste ā†’ Essential ā†’ Power user + - "installation" # Step-by-step install + - "first_agent" # Your first agent workflow + - "troubleshooting" # Common issues + + - name: "agents" + title: "25+ Specialized Agents" + sections: + - "agent_gallery" # All agents with search/filter + - "agent_categories" # By specialty + - "workflow_examples" # Multi-agent workflows + - "custom_agents" # Creating your own + +# Interactive elements for Amplifier +interactions: + animated_counters: true + progressive_setup_tiers: true + terminal_demos: true + copy_paste_commands: true + agent_carousel: true + + # Amplifier-specific counters + counters: + - name: "ideas_generated" + label: "Ideas Generated" + end_value: 1247 + duration: 2000 + format: "number" + - name: "time_saved" + label: "Hours Saved" + end_value: 1200 + duration: 1800 + format: "number" + - name: "specialized_agents" + label: "Specialized Agents" + end_value: 25 + duration: 1500 + format: "number" + +# Navigation for Amplifier +navigation: + style: "horizontal" + sticky: true + custom_items: + - name: "GitHub" + url: "https://github.com/user/amplifier" + external: true + - name: "Documentation" + url: "/docs" + external: false + - name: "Community" + url: "https://discord.gg/amplifier" + external: true + +# SEO optimized for Amplifier +seo: + meta_description_template: "Amplifier supercharges AI development with 25+ specialized agents, parallel workflows, and revolutionary paradigm shift from traditional coding to AI-amplified architecture." + keywords: + - "ai development" + - "claude code" + - "specialized agents" + - "development automation" + - "ai coding assistant" + - "parallel workflows" + - "modular architecture" + - "knowledge synthesis" + +# Content generation rules for Amplifier +content_rules: + # Revolution section configuration + revolution_metrics: + ideas_multiplier: 25 # 50 ā†’ 1250 ideas + time_reduction: 12 # 12 hours ā†’ 1 hour + quality_improvement: 5 # 5x better code quality + + # Agent showcase rules + agent_display: + featured_agents: + - "zen-architect" + - "bug-hunter" + - "security-guardian" + - "test-coverage" + - "performance-optimizer" + + categories: + architecture: ["zen-architect", "modular-builder"] + debugging: ["bug-hunter", "analysis-engine"] + security: ["security-guardian"] + testing: ["test-coverage"] + synthesis: ["concept-extractor", "insight-synthesizer"] + automation: ["post-task-cleanup", "integration-specialist"] + + # Setup tier customization + setup_tiers: + quick_taste: + focus: "First agent in 60 seconds" + demo_command: "Use zen-architect to design my notification system" + expected_output: "Complete architecture specification generated" + + essential: + focus: "Core workflow with 5 essential agents" + commands: + - "zen-architect for system design" + - "modular-builder for implementation" + - "test-coverage for quality assurance" + + power_user: + focus: "Full 25+ agent ecosystem mastery" + advanced_features: + - "Custom agent creation" + - "Parallel workflow orchestration" + - "Knowledge synthesis pipelines" + +# Trust building for Amplifier +trust_building: + progression: + skeptical: + emphasize: "concrete_examples" + show: ["quick_wins", "reversibility", "human_control"] + tone: "prove_value_first" + + curious: + emphasize: "how_it_works" + show: ["agent_specialization", "quality_assurance", "learning_curve"] + tone: "educational_depth" + + convinced: + emphasize: "mastery_path" + show: ["advanced_patterns", "customization", "community"] + tone: "empowering_growth" + +# Output customization +output: + file_naming: + index: "index.html" + setup: "setup.html" + agents: "agents.html" + examples: "examples.html" + + asset_organization: + css_file: "amplifier-styles.css" + js_file: "amplifier-script.js" + images_dir: "images" + + # Generation preferences + generation: + preserve_existing_assets: true + update_content_only: false + full_regeneration: true + backup_previous: true \ No newline at end of file diff --git a/website_generator/src/analyzer/repo_analyzer.py b/website_generator/src/analyzer/repo_analyzer.py new file mode 100644 index 00000000..6c89d4c0 --- /dev/null +++ b/website_generator/src/analyzer/repo_analyzer.py @@ -0,0 +1,579 @@ +""" +Repository analyzer for extracting project structure, capabilities, and paradigm indicators. +""" +import os +import json +from pathlib import Path +from typing import Dict, List, Optional, Any +from dataclasses import dataclass, asdict +from enum import Enum + + +class ParadigmType(Enum): + """Classification of paradigm shift significance""" + REVOLUTIONARY = "revolutionary" # Fundamental paradigm shift (3+ indicators) + EVOLUTIONARY = "evolutionary" # Significant improvements (2 indicators) + INCREMENTAL = "incremental" # Standard feature additions (0-1 indicators) + + +@dataclass +class ProjectInfo: + """Basic project metadata""" + name: str + description: str = "" + version: str = "" + language: str = "" + framework: str = "" + + +@dataclass +class AgentInfo: + """Information about a specialized agent""" + name: str + description: str + capabilities: List[str] + file_path: str + + +@dataclass +class CommandInfo: + """Information about a command or workflow""" + name: str + description: str + usage: str + file_path: str + + +@dataclass +class RepoAnalysis: + """Complete repository analysis results""" + project_info: ProjectInfo + paradigm_type: ParadigmType + agents: List[AgentInfo] + commands: List[CommandInfo] + workflows: List[str] + complexity_score: int + paradigm_indicators: Dict[str, int] + + +class RepositoryAnalyzer: + """Analyzes repository structure and capabilities""" + + def __init__(self, repo_path: str): + self.repo_path = Path(repo_path) + if not self.repo_path.exists(): + raise ValueError(f"Repository path does not exist: {repo_path}") + + def analyze_repository(self) -> RepoAnalysis: + """Perform complete repository analysis""" + print(f"Analyzing repository: {self.repo_path}") + + # Extract project metadata + print("Extracting project info...") + project_info = self._extract_project_info() + print(f"Project: {project_info.name} ({project_info.language})") + + # Extract capabilities + print("Extracting agents...") + agents = self._extract_agents() + print(f"Found {len(agents)} agents") + + print("Extracting commands...") + commands = self._extract_commands() + print(f"Found {len(commands)} commands") + + print("Extracting workflows...") + workflows = self._extract_workflows() + print(f"Found workflows: {workflows}") + + # Analyze complexity + print("Calculating complexity...") + complexity_score = self._calculate_complexity(agents, commands, workflows) + print(f"Complexity score: {complexity_score}") + + # Detect paradigm indicators + print("Detecting paradigm indicators...") + paradigm_indicators = self._detect_paradigm_indicators(agents, commands, workflows) + print(f"Paradigm indicators: {paradigm_indicators}") + + # Determine paradigm type + paradigm_type = self._classify_paradigm_shift(paradigm_indicators) + print(f"Paradigm type: {paradigm_type.value}") + + return RepoAnalysis( + project_info=project_info, + paradigm_type=paradigm_type, + agents=agents, + commands=commands, + workflows=workflows, + complexity_score=complexity_score, + paradigm_indicators=paradigm_indicators + ) + + def _extract_project_info(self) -> ProjectInfo: + """Extract basic project information""" + name = self.repo_path.name + description = "" + version = "" + language = "" + framework = "" + + # Try to extract from README + readme_files = ["README.md", "readme.md", "README.rst", "README.txt"] + for readme_file in readme_files: + readme_path = self.repo_path / readme_file + if readme_path.exists(): + with open(readme_path, 'r', encoding='utf-8') as f: + content = f.read() + # Extract description from first paragraph after title + lines = content.split('\n') + for i, line in enumerate(lines): + if line.strip() and not line.startswith('#') and not line.startswith('='): + description = line.strip() + break + break + + # Try to extract from pyproject.toml + pyproject_path = self.repo_path / "pyproject.toml" + if pyproject_path.exists(): + language = "Python" + try: + import tomllib + with open(pyproject_path, 'rb') as f: + data = tomllib.load(f) + if 'project' in data: + proj = data['project'] + if 'description' in proj and not description: + description = proj['description'] + if 'version' in proj: + version = proj['version'] + except Exception: + pass + + # Try to extract from package.json + package_json_path = self.repo_path / "package.json" + if package_json_path.exists(): + language = "JavaScript/Node.js" + try: + with open(package_json_path, 'r') as f: + data = json.load(f) + if 'description' in data and not description: + description = data['description'] + if 'version' in data: + version = data['version'] + except Exception: + pass + + return ProjectInfo( + name=name, + description=description, + version=version, + language=language, + framework=framework + ) + + def _extract_agents(self) -> List[AgentInfo]: + """Extract specialized agents from the repository""" + agents = [] + + # Check common agent locations + agent_patterns = [ + ".claude/agents", + "agents", + "subagents", + ".ai/agents" + ] + + for pattern in agent_patterns: + agent_dir = self.repo_path / pattern + if agent_dir.exists() and agent_dir.is_dir(): + print(f"Checking agent directory: {agent_dir}") + for agent_file in agent_dir.glob("*.md"): + print(f"Processing agent file: {agent_file.name}") + agent_info = self._parse_agent_file(agent_file) + if agent_info: + agents.append(agent_info) + else: + print(f"Failed to parse agent file: {agent_file.name}") + + return agents + + def _parse_agent_file(self, agent_file: Path) -> Optional[AgentInfo]: + """Parse an individual agent file""" + try: + with open(agent_file, 'r', encoding='utf-8') as f: + content = f.read() + + name = agent_file.stem + description = "" + capabilities = [] + + lines = content.split('\n') + current_section = None + in_frontmatter = False + frontmatter_done = False + + for i, line in enumerate(lines): + line_stripped = line.strip() + + # Handle YAML frontmatter + if i == 0 and line_stripped == "---": + in_frontmatter = True + continue + elif in_frontmatter and line_stripped == "---": + in_frontmatter = False + frontmatter_done = True + continue + elif in_frontmatter: + # Parse frontmatter for description + if line_stripped.startswith('description:'): + description = line_stripped[12:].strip() + # Remove quotes if present + if description.startswith('"') and description.endswith('"'): + description = description[1:-1] + elif description.startswith("'") and description.endswith("'"): + description = description[1:-1] + continue + + # Skip empty lines and process content after frontmatter + if not frontmatter_done: + continue + + if line_stripped.startswith('# '): + current_section = line_stripped[2:].lower() + elif line_stripped.startswith('## '): + current_section = line_stripped[3:].lower() + elif line_stripped.startswith('### '): + current_section = line_stripped[4:].lower() + elif line_stripped and not description and not line_stripped.startswith('#'): + # If no description from frontmatter, use first content line + if not description: + description = line_stripped[:200] # Limit description length + elif current_section and ('capabilit' in current_section or 'skill' in current_section or 'method' in current_section): + if line_stripped.startswith('- '): + capabilities.append(line_stripped[2:]) + elif line_stripped.startswith('- ') and not current_section: + # General bullet points as capabilities + capabilities.append(line_stripped[2:]) + + # Ensure we have a description + if not description and capabilities: + description = f"Specialized agent with {len(capabilities)} capabilities" + elif not description: + description = f"Specialized agent: {name.replace('-', ' ').title()}" + + return AgentInfo( + name=name, + description=description, + capabilities=capabilities, + file_path=str(agent_file.relative_to(self.repo_path)) + ) + + except Exception as e: + print(f"Error parsing agent file {agent_file}: {e}") + return None + + def _extract_commands(self) -> List[CommandInfo]: + """Extract commands and workflows from the repository""" + commands = [] + + # Check common command locations + command_patterns = [ + ".claude/commands/*.md", + "commands/*.md", + "scripts/*.md", + ".ai/commands/*.md" + ] + + for pattern in command_patterns: + command_dir = self.repo_path / pattern.split('/')[0] + if command_dir.exists() and command_dir.is_dir(): + for command_file in command_dir.glob("*.md"): + command_info = self._parse_command_file(command_file) + if command_info: + commands.append(command_info) + + # Also check Makefile for common commands + makefile_path = self.repo_path / "Makefile" + if makefile_path.exists(): + makefile_commands = self._parse_makefile(makefile_path) + commands.extend(makefile_commands) + + return commands + + def _parse_command_file(self, command_file: Path) -> Optional[CommandInfo]: + """Parse an individual command file""" + try: + with open(command_file, 'r', encoding='utf-8') as f: + content = f.read() + + name = command_file.stem + description = "" + usage = "" + + lines = content.split('\n') + for line in lines: + line = line.strip() + if line and not description and not line.startswith('#'): + description = line + break + + # Extract usage patterns (look for code blocks or command examples) + in_code_block = False + for line in lines: + if line.strip().startswith('```'): + in_code_block = not in_code_block + elif in_code_block and line.strip().startswith('make '): + usage = line.strip() + break + elif line.strip().startswith('$ ') or line.strip().startswith('> '): + usage = line.strip()[2:] + break + + return CommandInfo( + name=name, + description=description, + usage=usage, + file_path=str(command_file.relative_to(self.repo_path)) + ) + + except Exception as e: + print(f"Error parsing command file {command_file}: {e}") + return None + + def _parse_makefile(self, makefile_path: Path) -> List[CommandInfo]: + """Extract commands from Makefile""" + commands = [] + try: + with open(makefile_path, 'r', encoding='utf-8') as f: + content = f.read() + + lines = content.split('\n') + for line in lines: + line = line.strip() + if ':' in line and not line.startswith('#') and not line.startswith('\t'): + target = line.split(':')[0].strip() + if target and not target.startswith('.'): + commands.append(CommandInfo( + name=f"make {target}", + description=f"Makefile target: {target}", + usage=f"make {target}", + file_path="Makefile" + )) + + except Exception as e: + print(f"Error parsing Makefile: {e}") + + return commands + + def _extract_workflows(self) -> List[str]: + """Extract workflow patterns from the repository""" + workflows = [] + + # Check for GitHub Actions + gh_actions_path = self.repo_path / ".github" / "workflows" + if gh_actions_path.exists(): + workflows.append("GitHub Actions") + + # Check for other CI/CD indicators + ci_files = [ + ".travis.yml", + ".circleci/config.yml", + "azure-pipelines.yml", + "Jenkinsfile" + ] + + for ci_file in ci_files: + if (self.repo_path / ci_file).exists(): + workflows.append(ci_file.split('.')[0].replace('/', '_')) + + return workflows + + def _calculate_complexity(self, agents: List[AgentInfo], commands: List[CommandInfo], workflows: List[str]) -> int: + """Calculate overall project complexity score""" + complexity = 0 + + # Agent complexity + complexity += len(agents) + for agent in agents: + complexity += len(agent.capabilities) + + # Command complexity + complexity += len(commands) + + # Workflow complexity + complexity += len(workflows) * 2 + + # File structure complexity (optimized to avoid deep recursion) + try: + # Only count files in key directories to avoid performance issues + key_dirs = ['src', 'lib', 'amplifier', '.claude', 'docs'] + total_files = 0 + for key_dir in key_dirs: + dir_path = self.repo_path / key_dir + if dir_path.exists(): + total_files += sum(1 for _ in dir_path.rglob("*.py") if _.is_file()) + total_files += sum(1 for _ in dir_path.rglob("*.md") if _.is_file()) + complexity += total_files // 10 # Rough file count contribution + except Exception as e: + print(f"Warning: Could not calculate file complexity: {e}") + + return min(complexity, 100) # Cap at 100 + + def _detect_paradigm_indicators(self, agents: List[AgentInfo], commands: List[CommandInfo], workflows: List[str]) -> Dict[str, int]: + """Detect paradigm shift indicators""" + indicators = { + 'ai_amplification': 0, + 'specialized_agents': 0, + 'parallel_workflows': 0, + 'knowledge_synthesis': 0, + 'modular_architecture': 0 + } + + # Get all text for analysis + all_text = ' '.join([agent.description for agent in agents] + [cmd.description for cmd in commands]) + + # Also check project description and README + try: + readme_content = "" + readme_files = ["README.md", "readme.md", "AMPLIFIER_VISION.md"] + for readme_file in readme_files: + readme_path = self.repo_path / readme_file + if readme_path.exists(): + with open(readme_path, 'r', encoding='utf-8') as f: + readme_content += f.read() + " " + all_text += readme_content.lower() + except Exception: + pass + + # AI amplification indicators - enhanced detection + ai_keywords = ['claude', 'ai', 'llm', 'gpt', 'assistant', 'agent', 'amplifier', 'subagent', 'claude code'] + ai_score = 0 + for keyword in ai_keywords: + if keyword in all_text.lower(): + ai_score += 1 + + # Bonus for project name containing AI-related terms + if any(keyword in self.repo_path.name.lower() for keyword in ai_keywords): + ai_score += 2 + + indicators['ai_amplification'] = min(ai_score, 3) + + # Specialized agents - enhanced scoring + agent_count = len(agents) + if agent_count >= 20: # Amplifier has 25+ agents + indicators['specialized_agents'] = 3 + elif agent_count >= 10: + indicators['specialized_agents'] = 3 + elif agent_count >= 5: + indicators['specialized_agents'] = 2 + elif agent_count >= 1: + indicators['specialized_agents'] = 1 + + # Parallel workflows - enhanced detection + parallel_keywords = ['parallel', 'concurrent', 'async', 'multi', 'batch', 'pipeline'] + parallel_score = 0 + for keyword in parallel_keywords: + if keyword in all_text.lower(): + parallel_score += 1 + indicators['parallel_workflows'] = min(parallel_score, 3) + + # Knowledge synthesis - enhanced detection + knowledge_keywords = [ + 'synthesis', 'knowledge', 'extraction', 'mining', 'analysis', + 'insight', 'understanding', 'learning', 'memory', 'context', + 'reasoning', 'thinking', 'cognitive' + ] + knowledge_score = 0 + for keyword in knowledge_keywords: + if keyword in all_text.lower(): + knowledge_score += 1 + indicators['knowledge_synthesis'] = min(knowledge_score // 2, 3) # Scale down slightly + + # Modular architecture - enhanced detection + modular_keywords = [ + 'modular', 'module', 'component', 'brick', 'plugin', + 'microservice', 'service', 'toolkit', 'framework', + 'architecture', 'system', 'platform' + ] + modular_score = 0 + for keyword in modular_keywords: + if keyword in all_text.lower(): + modular_score += 1 + if modular_score >= 3: + indicators['modular_architecture'] = 3 + elif modular_score >= 1: + indicators['modular_architecture'] = 2 + + # Revolutionary project bonus - check for paradigm shift language + revolutionary_keywords = [ + 'revolution', 'paradigm', 'transformation', 'breakthrough', + 'game-chang', 'disruptive', 'fundamental', 'reimagin', + 'multiplier', 'supercharg', 'amplif' + ] + revolutionary_score = 0 + for keyword in revolutionary_keywords: + if keyword in all_text.lower(): + revolutionary_score += 1 + + # Boost all scores if revolutionary language is detected + if revolutionary_score >= 3: + for key in indicators: + indicators[key] = min(indicators[key] + 1, 3) + + return indicators + + def _classify_paradigm_shift(self, indicators: Dict[str, int]) -> ParadigmType: + """Classify the paradigm shift significance""" + total_score = sum(indicators.values()) + + # Check for specific revolutionary patterns + has_many_agents = indicators['specialized_agents'] >= 3 + has_ai_focus = indicators['ai_amplification'] >= 3 + has_knowledge_work = indicators['knowledge_synthesis'] >= 2 + + # Revolutionary: High total score OR strong AI+agents combination + if total_score >= 10 or (has_many_agents and has_ai_focus and has_knowledge_work): + return ParadigmType.REVOLUTIONARY + elif total_score >= 6 or (has_ai_focus and has_many_agents): + return ParadigmType.EVOLUTIONARY + else: + return ParadigmType.INCREMENTAL + + def save_analysis(self, analysis: RepoAnalysis, output_path: str) -> None: + """Save analysis results to JSON file""" + output_file = Path(output_path) + output_file.parent.mkdir(parents=True, exist_ok=True) + + # Convert to dict for JSON serialization + analysis_dict = asdict(analysis) + analysis_dict['paradigm_type'] = analysis.paradigm_type.value + + with open(output_file, 'w', encoding='utf-8') as f: + json.dump(analysis_dict, f, indent=2, ensure_ascii=False) + + print(f"Analysis saved to: {output_file}") + + +if __name__ == "__main__": + import sys + if len(sys.argv) != 2: + print("Usage: python repo_analyzer.py ") + sys.exit(1) + + repo_path = sys.argv[1] + analyzer = RepositoryAnalyzer(repo_path) + analysis = analyzer.analyze_repository() + + print(f"\nRepository Analysis Results:") + print(f"Project: {analysis.project_info.name}") + print(f"Description: {analysis.project_info.description}") + print(f"Paradigm Type: {analysis.paradigm_type.value}") + print(f"Complexity Score: {analysis.complexity_score}") + print(f"Agents Found: {len(analysis.agents)}") + print(f"Commands Found: {len(analysis.commands)}") + print(f"Workflows: {', '.join(analysis.workflows) if analysis.workflows else 'None'}") + print(f"Paradigm Indicators: {analysis.paradigm_indicators}") + + # Save analysis + analyzer.save_analysis(analysis, f"{repo_path}_analysis.json") \ No newline at end of file diff --git a/website_generator/src/config_loader.py b/website_generator/src/config_loader.py new file mode 100644 index 00000000..6bb599fd --- /dev/null +++ b/website_generator/src/config_loader.py @@ -0,0 +1,215 @@ +""" +Configuration loader for website generator. +Handles loading and merging YAML configuration files. +""" +import os +import yaml +from pathlib import Path +from typing import Dict, Any, Optional +from dataclasses import dataclass + + +@dataclass +class SiteConfig: + """Complete site configuration""" + site: Dict[str, Any] + content_strategy: Dict[str, Any] + design_system: Dict[str, Any] + pages: list + interactions: Dict[str, Any] + navigation: Dict[str, Any] + seo: Dict[str, Any] + build: Dict[str, Any] + responsive: Dict[str, Any] + + +class ConfigLoader: + """Loads and manages website generator configuration""" + + def __init__(self, config_dir: str = None): + if config_dir is None: + self.config_dir = Path(__file__).parent.parent / "config" + else: + self.config_dir = Path(config_dir) + + if not self.config_dir.exists(): + raise ValueError(f"Configuration directory does not exist: {self.config_dir}") + + def load_base_config(self) -> Dict[str, Any]: + """Load base site template configuration""" + site_template_path = self.config_dir / "site_template.yaml" + content_patterns_path = self.config_dir / "content_patterns.yaml" + + if not site_template_path.exists(): + raise FileNotFoundError(f"Base site template not found: {site_template_path}") + + # Load site template + with open(site_template_path, 'r', encoding='utf-8') as f: + site_config = yaml.safe_load(f) + + # Load content patterns if available + if content_patterns_path.exists(): + with open(content_patterns_path, 'r', encoding='utf-8') as f: + content_patterns = yaml.safe_load(f) + site_config['content_patterns'] = content_patterns + + return site_config + + def load_project_config(self, config_path: str) -> Dict[str, Any]: + """Load project-specific configuration""" + config_file = Path(config_path) + if not config_file.exists(): + raise FileNotFoundError(f"Project configuration not found: {config_path}") + + with open(config_file, 'r', encoding='utf-8') as f: + return yaml.safe_load(f) + + def merge_configs(self, base_config: Dict[str, Any], project_config: Dict[str, Any]) -> Dict[str, Any]: + """Merge project configuration with base configuration""" + def deep_merge(base: Dict, override: Dict) -> Dict: + result = base.copy() + for key, value in override.items(): + if key in result and isinstance(result[key], dict) and isinstance(value, dict): + result[key] = deep_merge(result[key], value) + else: + result[key] = value + return result + + return deep_merge(base_config, project_config) + + def load_full_config(self, project_config_path: Optional[str] = None) -> SiteConfig: + """Load complete configuration, merging base and project configs""" + # Load base configuration + base_config = self.load_base_config() + + # Merge with project configuration if provided + if project_config_path: + project_config = self.load_project_config(project_config_path) + final_config = self.merge_configs(base_config, project_config) + else: + final_config = base_config + + # Validate required sections + required_sections = ['site', 'content_strategy', 'design_system', 'pages'] + for section in required_sections: + if section not in final_config: + raise ValueError(f"Required configuration section missing: {section}") + + # Create SiteConfig object + return SiteConfig( + site=final_config.get('site', {}), + content_strategy=final_config.get('content_strategy', {}), + design_system=final_config.get('design_system', {}), + pages=final_config.get('pages', []), + interactions=final_config.get('interactions', {}), + navigation=final_config.get('navigation', {}), + seo=final_config.get('seo', {}), + build=final_config.get('build', {}), + responsive=final_config.get('responsive', {}) + ) + + def validate_config(self, config: SiteConfig) -> bool: + """Validate configuration for completeness and consistency""" + # Check required site information + if not config.site.get('name'): + raise ValueError("Site name is required") + + if not config.site.get('description'): + raise ValueError("Site description is required") + + # Check design system + if not config.design_system.get('colors'): + print("Warning: No color palette defined, using defaults") + + # Check pages + if not config.pages: + raise ValueError("At least one page must be defined") + + # Validate page structure + for page in config.pages: + if not page.get('name'): + raise ValueError("Page name is required") + if not page.get('sections'): + raise ValueError(f"Page {page.get('name')} must have sections") + + return True + + def get_content_patterns(self, config: SiteConfig) -> Dict[str, Any]: + """Extract content generation patterns from configuration""" + # This will be used by the content generation engine + return { + 'paradigm_detection': config.content_strategy.get('paradigm_shift_detection', True), + 'progressive_disclosure': config.content_strategy.get('progressive_disclosure', True), + 'trust_building': config.content_strategy.get('trust_building_focus', True), + 'role_transformation': config.content_strategy.get('role_transformation_emphasis', True) + } + + def export_config(self, config: SiteConfig, output_path: str) -> None: + """Export merged configuration to file""" + config_dict = { + 'site': config.site, + 'content_strategy': config.content_strategy, + 'design_system': config.design_system, + 'pages': config.pages, + 'interactions': config.interactions, + 'navigation': config.navigation, + 'seo': config.seo, + 'build': config.build, + 'responsive': config.responsive + } + + output_file = Path(output_path) + output_file.parent.mkdir(parents=True, exist_ok=True) + + with open(output_file, 'w', encoding='utf-8') as f: + yaml.dump(config_dict, f, default_flow_style=False, sort_keys=False, indent=2) + + print(f"Configuration exported to: {output_file}") + + +def test_config_loader(): + """Test the configuration loader with Amplifier example""" + loader = ConfigLoader() + + try: + # Test base config loading + print("Loading base configuration...") + base_config = loader.load_base_config() + print(f"āœ“ Base config loaded with {len(base_config)} sections") + + # Test project config loading + project_config_path = Path(__file__).parent.parent / "examples" / "amplifier_config.yaml" + print(f"Loading project configuration from {project_config_path}...") + + full_config = loader.load_full_config(str(project_config_path)) + print(f"āœ“ Full config loaded for project: {full_config.site['name']}") + + # Test validation + print("Validating configuration...") + if loader.validate_config(full_config): + print("āœ“ Configuration validation passed") + + # Test content patterns extraction + content_patterns = loader.get_content_patterns(full_config) + print(f"āœ“ Content patterns extracted: {list(content_patterns.keys())}") + + # Test export + export_path = "/tmp/test_config_export.yaml" + loader.export_config(full_config, export_path) + + print("\nšŸ“Š Configuration Summary:") + print(f" Site: {full_config.site['name']}") + print(f" Theme: {full_config.site['theme']}") + print(f" Pages: {len(full_config.pages)}") + print(f" Color Palette: {full_config.design_system['color_palette']}") + print(f" Animation Level: {full_config.design_system['animation_level']}") + + return True + + except Exception as e: + print(f"āŒ Configuration test failed: {e}") + return False + + +if __name__ == "__main__": + test_config_loader() \ No newline at end of file diff --git a/website_generator/src/content/content_generator.py b/website_generator/src/content/content_generator.py new file mode 100644 index 00000000..e3b9dde4 --- /dev/null +++ b/website_generator/src/content/content_generator.py @@ -0,0 +1,744 @@ +""" +Content generator for website creation. +Generates content based on repository analysis and configuration. +""" +from typing import Dict, List, Any, Optional +from dataclasses import dataclass +from pathlib import Path + +# Import our components +import sys +sys.path.append(str(Path(__file__).parent.parent)) +from analyzer.repo_analyzer import RepoAnalysis, ParadigmType, AgentInfo, CommandInfo +from config_loader import SiteConfig + + +@dataclass +class RevolutionContent: + """Content for revolutionary paradigm section""" + title: str + subtitle: str + problem_statement: str + paradigm_comparison: Dict[str, Any] + multiplier_effect: Dict[str, Any] + role_transformation: Dict[str, Any] + + +@dataclass +class ProgressiveSetup: + """Progressive setup tier content""" + tiers: List[Dict[str, Any]] + + +@dataclass +class AgentShowcase: + """Agent showcase content""" + featured_agents: List[Dict[str, Any]] + agent_categories: Dict[str, List[Dict[str, Any]]] + total_count: int + + +@dataclass +class GeneratedContent: + """Complete generated content for a website""" + revolution_section: Optional[RevolutionContent] + progressive_setup: ProgressiveSetup + agent_showcase: AgentShowcase + hero_section: Dict[str, Any] + overview_section: Dict[str, Any] + examples_section: Dict[str, Any] + + +class ContentGenerator: + """Generates website content based on repository analysis""" + + def __init__(self, config: SiteConfig): + self.config = config + + def generate_content(self, analysis: RepoAnalysis) -> GeneratedContent: + """Generate complete website content""" + print(f"Generating content for {analysis.paradigm_type.value} paradigm...") + + # Generate revolution section (only for revolutionary paradigm) + revolution_section = None + if analysis.paradigm_type == ParadigmType.REVOLUTIONARY: + revolution_section = self._generate_revolution_section(analysis) + + # Generate other sections + progressive_setup = self._generate_progressive_setup(analysis) + agent_showcase = self._generate_agent_showcase(analysis) + hero_section = self._generate_hero_section(analysis) + overview_section = self._generate_overview_section(analysis) + examples_section = self._generate_examples_section(analysis) + + return GeneratedContent( + revolution_section=revolution_section, + progressive_setup=progressive_setup, + agent_showcase=agent_showcase, + hero_section=hero_section, + overview_section=overview_section, + examples_section=examples_section + ) + + def _generate_revolution_section(self, analysis: RepoAnalysis) -> RevolutionContent: + """Generate revolutionary paradigm content""" + project_name = analysis.project_info.name.title() + + # Generate problem statement + problem_statement = self._generate_problem_statement(analysis) + + # Generate paradigm comparison + paradigm_comparison = self._generate_paradigm_comparison(analysis) + + # Generate multiplier effect + multiplier_effect = self._generate_multiplier_effect(analysis) + + # Generate role transformation + role_transformation = self._generate_role_transformation(analysis) + + return RevolutionContent( + title="The Development Revolution", + subtitle=f"Why {project_name} Changes Everything", + problem_statement=problem_statement, + paradigm_comparison=paradigm_comparison, + multiplier_effect=multiplier_effect, + role_transformation=role_transformation + ) + + def _generate_problem_statement(self, analysis: RepoAnalysis) -> str: + """Generate problem statement for revolutionary tools""" + agent_count = len(analysis.agents) + + if agent_count >= 20: + scale_desc = "massive complexity" + solution_desc = "specialized AI agents" + elif agent_count >= 10: + scale_desc = "growing complexity" + solution_desc = "intelligent automation" + else: + scale_desc = "increasing demands" + solution_desc = "AI-powered assistance" + + return f"""Traditional development approaches struggle with {scale_desc} of modern software projects. + Developers spend countless hours on repetitive tasks, debugging obscure issues, and managing intricate architectures. + {analysis.project_info.name.title()} revolutionizes this process through {solution_desc}, transforming + how we approach software development entirely.""" + + def _generate_paradigm_comparison(self, analysis: RepoAnalysis) -> Dict[str, Any]: + """Generate before/after paradigm comparison""" + agent_count = len(analysis.agents) + + comparison = { + "categories": [ + { + "name": "Development Speed", + "before": "Hours per feature", + "after": "Minutes per feature", + "improvement": "10-50x faster" + }, + { + "name": "Code Quality", + "before": "Manual reviews", + "after": "AI-powered analysis", + "improvement": "Consistent excellence" + }, + { + "name": "Architecture", + "before": "Ad-hoc decisions", + "after": "Specialized expertise", + "improvement": "Professional patterns" + }, + { + "name": "Debugging", + "before": "Manual investigation", + "after": "Systematic analysis", + "improvement": "Root cause focus" + } + ] + } + + if agent_count >= 20: + comparison["categories"].append({ + "name": "Specialization", + "before": "Generalist approach", + "after": f"{agent_count}+ expert agents", + "improvement": "Domain expertise" + }) + + return comparison + + def _generate_multiplier_effect(self, analysis: RepoAnalysis) -> Dict[str, Any]: + """Generate capability multiplication metrics""" + agent_count = len(analysis.agents) + complexity = analysis.complexity_score + + # Calculate multipliers based on project characteristics + if agent_count >= 20 and complexity >= 80: + # High complexity, many agents (like Amplifier) + ideas_multiplier = 25 # 50 ā†’ 1250 + time_reduction = 12 # 12 hours ā†’ 1 hour + elif agent_count >= 10: + ideas_multiplier = 10 # 50 ā†’ 500 + time_reduction = 6 # 6 hours ā†’ 1 hour + else: + ideas_multiplier = 5 # 50 ā†’ 250 + time_reduction = 3 # 3 hours ā†’ 1 hour + + return { + "metrics": [ + { + "name": "Ideas Generated", + "old_value": 50, + "new_value": 50 * ideas_multiplier, + "unit": "per month", + "multiplier": ideas_multiplier + }, + { + "name": "Implementation Time", + "old_value": time_reduction, + "new_value": 1, + "unit": "hours", + "multiplier": time_reduction, + "inverse": True + }, + { + "name": "Code Quality", + "old_value": 70, + "new_value": 95, + "unit": "% excellent", + "multiplier": 1.36 + } + ] + } + + def _generate_role_transformation(self, analysis: RepoAnalysis) -> Dict[str, Any]: + """Generate role transformation narrative""" + agent_count = len(analysis.agents) + + if agent_count >= 20: + # High-agent environments like Amplifier + return { + "transformation_type": "elevation", + "old_role": { + "title": "Traditional Developer", + "characteristics": [ + "Code line by line manually", + "Debug through trial and error", + "Work on single tasks sequentially", + "Rely on personal knowledge only", + "Spend hours on repetitive work" + ] + }, + "new_role": { + "title": "AI-Amplified Architect", + "characteristics": [ + "Design and orchestrate systems", + "Deploy specialized expert agents", + "Coordinate parallel development streams", + "Access distributed expertise instantly", + "Focus on creative problem-solving" + ] + }, + "transformation_message": "You don't become obsoleteā€”you become orchestrator of an expert team." + } + elif agent_count >= 5: + return { + "transformation_type": "enhancement", + "old_role": { + "title": "Solo Developer", + "characteristics": [ + "Handle all aspects personally", + "Limited by individual expertise", + "Sequential task completion" + ] + }, + "new_role": { + "title": "Augmented Developer", + "characteristics": [ + "Leverage AI specialists for complex tasks", + "Access expert knowledge on demand", + "Parallel task execution" + ] + } + } + else: + return { + "transformation_type": "assistance", + "old_role": { + "title": "Manual Developer", + "characteristics": [ + "All work done manually", + "Time-consuming processes" + ] + }, + "new_role": { + "title": "AI-Assisted Developer", + "characteristics": [ + "AI handles routine tasks", + "Accelerated development cycle" + ] + } + } + + def _generate_progressive_setup(self, analysis: RepoAnalysis) -> ProgressiveSetup: + """Generate progressive setup tiers""" + project_name = analysis.project_info.name + agent_count = len(analysis.agents) + + tiers = [] + + # Quick Taste (1 minute) + quick_taste = { + "name": "Quick Taste", + "duration": "1 minute", + "description": "Experience the power immediately", + "focus": f"Your first {project_name} agent", + "steps": [ + f"Install {project_name}", + "Run your first agent command", + "See immediate results" + ] + } + + if agent_count >= 5: + quick_taste["demo_command"] = f"Use zen-architect to design my authentication system" + quick_taste["expected_result"] = "Complete system architecture generated in seconds" + else: + quick_taste["demo_command"] = f"Run {project_name} --help" + quick_taste["expected_result"] = "See available capabilities" + + tiers.append(quick_taste) + + # Essential Setup (5 minutes) + essential = { + "name": "Essential Setup", + "duration": "5 minutes", + "description": "Core features and workflows", + "focus": f"Essential {project_name} workflow", + "steps": [ + "Configure core settings", + "Learn key commands", + "Complete first real task" + ] + } + + if agent_count >= 10: + essential["workflow"] = "Multi-agent workflow with 3-5 essential agents" + else: + essential["workflow"] = "Core feature demonstration" + + tiers.append(essential) + + # Power User (15+ minutes) - only for complex systems + if analysis.complexity_score >= 50 or agent_count >= 5: + power_user = { + "name": "Power User", + "duration": "15+ minutes", + "description": "Full ecosystem mastery", + "focus": f"Complete {project_name} mastery", + "steps": [ + "Advanced configuration", + "Custom integrations", + "Expert workflows" + ] + } + + if agent_count >= 20: + power_user["mastery_features"] = [ + f"All {agent_count}+ specialized agents", + "Parallel workflow orchestration", + "Custom agent creation", + "Advanced automation patterns" + ] + elif agent_count >= 10: + power_user["mastery_features"] = [ + "Advanced agent combinations", + "Complex workflow patterns", + "Integration customization" + ] + else: + power_user["mastery_features"] = [ + "Advanced features", + "Customization options", + "Expert patterns" + ] + + tiers.append(power_user) + + return ProgressiveSetup(tiers=tiers) + + def _generate_agent_showcase(self, analysis: RepoAnalysis) -> AgentShowcase: + """Generate agent showcase content""" + agents = analysis.agents + total_count = len(agents) + + # Select featured agents (first 6 or most important) + featured_agents = [] + for i, agent in enumerate(agents[:6]): + featured_agents.append(self._create_rich_agent_content(agent)) + + # Categorize all agents with rich content + categories = { + "Architecture": [], + "Development": [], + "Quality": [], + "Analysis": [], + "Automation": [], + "Other": [] + } + + for agent in agents: + category = self._categorize_agent(agent.name) + rich_agent = self._create_rich_agent_content(agent) + categories[category].append(rich_agent) + + # Remove empty categories + categories = {k: v for k, v in categories.items() if v} + + return AgentShowcase( + featured_agents=featured_agents, + agent_categories=categories, + total_count=total_count + ) + + def _create_rich_agent_content(self, agent: AgentInfo) -> Dict[str, Any]: + """Create rich, detailed content for an agent like the instructor site""" + agent_name = agent.name + category = self._categorize_agent(agent_name) + + # Generate detailed description based on agent name and existing description + detailed_description = self._generate_detailed_agent_description(agent) + + # Generate example usage and output + example_usage = self._generate_agent_usage_example(agent) + example_output = self._generate_agent_output_example(agent) + + # Generate key capabilities + key_capabilities = self._generate_agent_key_capabilities(agent) + + # Generate use cases + use_cases = self._generate_agent_use_cases(agent) + + return { + "name": agent_name, + "category": category, + "description": detailed_description, + "capabilities": key_capabilities, + "capabilities_count": len(agent.capabilities), + "example_usage": example_usage, + "example_output": example_output, + "use_cases": use_cases, + "file_path": agent.file_path + } + + def _generate_detailed_agent_description(self, agent: AgentInfo) -> str: + """Generate detailed agent description based on name and role""" + name = agent.name + existing_desc = agent.description + + # Agent-specific detailed descriptions + if name == "zen-architect": + return """The master architect who embodies ruthless simplicity and Wabi-sabi philosophy. Operates in three powerful modes: + ANALYZE for problem decomposition, ARCHITECT for system design, and REVIEW for code quality assessment. + Creates clear specifications that guide implementation, focusing on essential patterns over unnecessary abstractions.""" + + elif name == "bug-hunter": + return """Specialized debugging expert focused on systematically finding and fixing bugs. Uses hypothesis-driven debugging + to efficiently locate root causes and implement minimal fixes. Follows a methodical approach that prevents future issues + while maintaining code simplicity and reliability.""" + + elif name == "security-guardian": + return """Comprehensive security analysis expert that performs vulnerability assessments and security audits. + Checks for common vulnerabilities (OWASP Top 10), detects hardcoded secrets, validates input/output security, + and ensures data protection measures are in place before production deployments.""" + + elif name == "test-coverage": + return """Expert at analyzing test coverage and identifying gaps to suggest comprehensive test cases. + Ensures thorough testing without over-testing, following the testing pyramid principle. + Identifies edge cases and creates strategic test suites that maximize quality assurance.""" + + elif name == "performance-optimizer": + return """Analyzes and improves code and system performance through data-driven optimization. + Profiles applications to identify bottlenecks, optimizes algorithms, improves database queries, + and addresses performance concerns with a measure-first approach.""" + + elif name == "modular-builder": + return """Primary implementation agent that builds code from zen-architect specifications. + Creates self-contained, regeneratable modules following the 'bricks and studs' philosophy. + Transforms architectural designs into working code with proper separation of concerns.""" + + elif "analysis" in name or "synthesis" in name: + return f"""Advanced analysis agent specialized in {name.replace('-', ' ').replace('_', ' ')}. + Processes complex information to extract insights and patterns. Uses multi-mode analysis + to provide deep understanding and actionable recommendations for development decisions.""" + + else: + # Fallback to enhanced version of existing description + if existing_desc and len(existing_desc) > 50: + return existing_desc + else: + return f"""Specialized agent focused on {name.replace('-', ' ').replace('_', ' ')} tasks. + Provides expert-level capabilities and follows best practices to ensure high-quality outcomes. + Integrates seamlessly with other agents in the development ecosystem.""" + + def _generate_agent_usage_example(self, agent: AgentInfo) -> str: + """Generate usage example for an agent""" + name = agent.name + + examples = { + "zen-architect": "Use zen-architect to design a user notification system", + "bug-hunter": "Use bug-hunter to investigate why the authentication system is throwing intermittent errors", + "security-guardian": "Use security-guardian to review this API endpoint before production deployment", + "test-coverage": "Use test-coverage to analyze gaps in our payment processing test suite", + "performance-optimizer": "Use performance-optimizer to speed up our database queries in the user dashboard", + "modular-builder": "Use modular-builder to implement the notification system from zen-architect's specification", + "integration-specialist": "Use integration-specialist to connect our system with the new payment API", + "content-researcher": "Use content-researcher to find relevant patterns for implementing OAuth authentication" + } + + return examples.get(name, f"Use {name} to handle {name.replace('-', ' ')} tasks efficiently") + + def _generate_agent_output_example(self, agent: AgentInfo) -> str: + """Generate example output for an agent""" + name = agent.name + + outputs = { + "zen-architect": "ā†’ Returns: Problem analysis, 3 solution approaches with trade-offs, modular specification", + "bug-hunter": "ā†’ Returns: Root cause analysis, step-by-step debugging plan, fix implementation with tests", + "security-guardian": "ā†’ Returns: Security assessment report, vulnerability findings, remediation recommendations", + "test-coverage": "ā†’ Returns: Coverage analysis, identified gaps, comprehensive test case suggestions", + "performance-optimizer": "ā†’ Returns: Performance bottleneck analysis, optimization recommendations, implementation plan", + "modular-builder": "ā†’ Returns: Working implementation with tests, documentation, and integration instructions" + } + + return outputs.get(name, f"ā†’ Returns: Comprehensive {name.replace('-', ' ')} analysis and recommendations") + + def _generate_agent_key_capabilities(self, agent: AgentInfo) -> List[str]: + """Generate key capabilities for an agent""" + name = agent.name + + # Use existing capabilities if available and detailed + if agent.capabilities and len(agent.capabilities) >= 3: + return agent.capabilities[:6] # Top 6 capabilities + + # Generate capabilities based on agent type + capabilities_map = { + "zen-architect": [ + "Analysis-first development approach", + "Modular 'bricks & studs' architecture", + "Clean contract specifications", + "Complexity elimination strategies", + "80/20 principle application", + "Philosophy compliance review" + ], + "bug-hunter": [ + "Hypothesis-driven debugging methodology", + "Root cause analysis techniques", + "Systematic error reproduction", + "Minimal fix implementation", + "Prevention strategy development", + "Code quality improvement" + ], + "security-guardian": [ + "OWASP Top 10 vulnerability scanning", + "Hardcoded secrets detection", + "Input/output validation checks", + "Authentication system review", + "Data protection compliance", + "Production security audits" + ], + "test-coverage": [ + "Coverage gap identification", + "Test strategy development", + "Edge case discovery", + "Testing pyramid optimization", + "Quality assurance planning", + "Test maintenance guidelines" + ] + } + + return capabilities_map.get(name, [ + f"Expert {name.replace('-', ' ')} analysis", + "Best practice implementation", + "Quality assurance focus", + "Integration with development workflow", + "Comprehensive documentation", + "Scalable solution design" + ]) + + def _generate_agent_use_cases(self, agent: AgentInfo) -> List[str]: + """Generate use cases for an agent""" + name = agent.name + + use_cases_map = { + "zen-architect": [ + "Designing new feature architectures", + "Refactoring complex legacy systems", + "Creating modular component specifications", + "Establishing coding standards and patterns" + ], + "bug-hunter": [ + "Investigating production issues", + "Debugging intermittent failures", + "Analyzing test failures", + "Resolving performance problems" + ], + "security-guardian": [ + "Pre-deployment security reviews", + "API security assessments", + "Authentication system audits", + "Data privacy compliance checks" + ] + } + + return use_cases_map.get(name, [ + f"Complex {name.replace('-', ' ')} challenges", + "Quality improvement initiatives", + "Best practice implementation", + "Team knowledge enhancement" + ]) + + def _categorize_agent(self, agent_name: str) -> str: + """Categorize agent based on name patterns""" + name_lower = agent_name.lower() + + if any(keyword in name_lower for keyword in ['architect', 'design', 'modular', 'builder']): + return "Architecture" + elif any(keyword in name_lower for keyword in ['bug', 'debug', 'test', 'security', 'performance']): + return "Quality" + elif any(keyword in name_lower for keyword in ['analysis', 'synthesis', 'extract', 'insight']): + return "Analysis" + elif any(keyword in name_lower for keyword in ['automation', 'cleanup', 'integration']): + return "Automation" + elif any(keyword in name_lower for keyword in ['contract', 'api', 'database']): + return "Development" + else: + return "Other" + + def _generate_hero_section(self, analysis: RepoAnalysis) -> Dict[str, Any]: + """Generate hero section content""" + project_name = analysis.project_info.name.title() + description = analysis.project_info.description or f"Supercharge your development with {project_name}" + + return { + "title": project_name, + "tagline": self.config.site.get('tagline', f"Next-Generation Development Tool"), + "description": description, + "cta_primary": "Get Started", + "cta_secondary": "View Examples", + "features_preview": [ + f"{len(analysis.agents)} Specialized Agents", + f"Complexity Score: {analysis.complexity_score}", + f"{analysis.paradigm_type.value.title()} Impact" + ] + } + + def _generate_overview_section(self, analysis: RepoAnalysis) -> Dict[str, Any]: + """Generate overview section content""" + return { + "title": "Overview", + "description": f"Understand how {analysis.project_info.name} transforms your development workflow", + "key_points": [ + { + "title": "Specialized Agents", + "description": f"{len(analysis.agents)} expert agents handle different aspects of development", + "icon": "agents" + }, + { + "title": "Parallel Processing", + "description": "Execute multiple development tasks simultaneously", + "icon": "parallel" + }, + { + "title": "Quality Assurance", + "description": "Built-in quality checks and best practices enforcement", + "icon": "quality" + } + ] + } + + def _generate_examples_section(self, analysis: RepoAnalysis) -> Dict[str, Any]: + """Generate examples section content""" + # Extract example commands from the analysis + example_commands = [] + for cmd in analysis.commands[:5]: # Top 5 commands + if cmd.usage: + example_commands.append({ + "name": cmd.name, + "command": cmd.usage, + "description": cmd.description + }) + + return { + "title": "Examples", + "description": "Real workflows and commands you can use immediately", + "examples": example_commands, + "workflows": [ + { + "name": "Full Development Cycle", + "steps": [ + "Design with zen-architect", + "Build with modular-builder", + "Test with test-coverage", + "Review with security-guardian" + ] + } + ] + } + + +def test_content_generation(): + """Test content generation with Amplifier analysis""" + # This would normally load from the actual analysis + # For testing, we'll create a mock analysis + from analyzer.repo_analyzer import ProjectInfo, RepoAnalysis, ParadigmType, AgentInfo + + # Mock analysis for testing + project_info = ProjectInfo( + name="amplifier", + description="A complete development environment that supercharges AI coding assistants", + language="Python" + ) + + mock_agents = [ + AgentInfo("zen-architect", "Designs systems with ruthless simplicity", ["architecture", "design"], ".claude/agents/zen-architect.md"), + AgentInfo("bug-hunter", "Systematic debugging expert", ["debugging", "analysis"], ".claude/agents/bug-hunter.md"), + AgentInfo("security-guardian", "Security analysis and best practices", ["security", "audit"], ".claude/agents/security-guardian.md"), + ] + + mock_commands = [ + CommandInfo("zen-architect", "Design system architecture", "make design", ".claude/commands/design.md"), + CommandInfo("test-suite", "Run comprehensive tests", "make test", "Makefile"), + ] + + mock_analysis = RepoAnalysis( + project_info=project_info, + paradigm_type=ParadigmType.REVOLUTIONARY, + agents=mock_agents, + commands=mock_commands, + workflows=[], + complexity_score=100, + paradigm_indicators={'ai_amplification': 3, 'specialized_agents': 3} + ) + + # Load config + from config_loader import ConfigLoader + loader = ConfigLoader() + config = loader.load_full_config() + + # Generate content + generator = ContentGenerator(config) + content = generator.generate_content(mock_analysis) + + print("šŸŽÆ Content Generation Test Results:") + print(f"Revolution Section: {content.revolution_section.title if content.revolution_section else 'None'}") + print(f"Setup Tiers: {len(content.progressive_setup.tiers)}") + print(f"Featured Agents: {len(content.agent_showcase.featured_agents)}") + print(f"Agent Categories: {list(content.agent_showcase.agent_categories.keys())}") + print(f"Hero Title: {content.hero_section['title']}") + + return True + + +if __name__ == "__main__": + test_content_generation() \ No newline at end of file diff --git a/website_generator/src/content/template_engine.py b/website_generator/src/content/template_engine.py new file mode 100644 index 00000000..f3e3e256 --- /dev/null +++ b/website_generator/src/content/template_engine.py @@ -0,0 +1,788 @@ +""" +Template engine for converting generated content into HTML. +Uses Jinja2 for template processing with custom filters and functions. +""" +import os +import json +from pathlib import Path +from typing import Dict, Any, List, Optional +from datetime import datetime + +try: + from jinja2 import Environment, FileSystemLoader, select_autoescape +except ImportError: + print("Installing Jinja2...") + import subprocess + subprocess.run(["pip", "install", "jinja2"], check=True) + from jinja2 import Environment, FileSystemLoader, select_autoescape + +# Import our components +import sys +sys.path.append(str(Path(__file__).parent.parent)) +from config_loader import SiteConfig +from content.content_generator import GeneratedContent + + +class TemplateEngine: + """Converts generated content into HTML using Jinja2 templates""" + + def __init__(self, config: SiteConfig, templates_dir: str = None, css_filename: str = "styles.css"): + self.config = config + self.css_filename = css_filename + + if templates_dir is None: + self.templates_dir = Path(__file__).parent.parent.parent / "templates" + else: + self.templates_dir = Path(templates_dir) + + # Initialize Jinja2 environment + self.env = Environment( + loader=FileSystemLoader(str(self.templates_dir)), + autoescape=select_autoescape(['html', 'xml']), + trim_blocks=True, + lstrip_blocks=True + ) + + # Add custom filters and functions + self._setup_template_functions() + + def _setup_template_functions(self): + """Add custom Jinja2 filters and functions""" + + # Custom filters + self.env.filters['format_number'] = self._format_number + self.env.filters['truncate_words'] = self._truncate_words + self.env.filters['slug'] = self._slugify + self.env.filters['agent_badge'] = self._agent_badge + + # Global functions + self.env.globals['now'] = datetime.now + self.env.globals['config'] = self.config + self.env.globals['get_color'] = self._get_color + self.env.globals['get_icon'] = self._get_icon + + def _format_number(self, value: int) -> str: + """Format numbers with commas""" + if isinstance(value, (int, float)): + return f"{value:,}" + return str(value) + + def _truncate_words(self, text: str, words: int = 20) -> str: + """Truncate text to specified number of words""" + if not text: + return "" + word_list = text.split() + if len(word_list) <= words: + return text + return " ".join(word_list[:words]) + "..." + + def _slugify(self, text: str) -> str: + """Convert text to URL-friendly slug""" + import re + slug = re.sub(r'[^\w\s-]', '', text.lower()) + slug = re.sub(r'[-\s]+', '-', slug) + return slug.strip('-') + + def _agent_badge(self, agent_name: str) -> str: + """Get CSS class for agent badge based on category""" + name_lower = agent_name.lower() + + if any(keyword in name_lower for keyword in ['architect', 'design', 'modular']): + return 'badge-architecture' + elif any(keyword in name_lower for keyword in ['bug', 'debug', 'test', 'security']): + return 'badge-quality' + elif any(keyword in name_lower for keyword in ['analysis', 'synthesis', 'extract']): + return 'badge-analysis' + elif any(keyword in name_lower for keyword in ['automation', 'cleanup']): + return 'badge-automation' + else: + return 'badge-development' + + def _get_color(self, color_name: str) -> str: + """Get color value from design system""" + colors = self.config.design_system.get('colors', {}) + return colors.get(color_name, '#2563eb') # Default blue + + def _get_icon(self, icon_name: str) -> str: + """Get icon class/SVG for given icon name""" + # Simple icon mapping - could be enhanced with actual icon library + icon_map = { + 'agents': 'šŸ¤–', + 'parallel': 'āš”', + 'quality': 'āœ…', + 'architecture': 'šŸ—ļø', + 'security': 'šŸ”’', + 'testing': 'šŸ§Ŗ', + 'analysis': 'šŸ“Š', + 'automation': 'āš™ļø', + 'development': 'šŸ’»' + } + return icon_map.get(icon_name, 'šŸ“„') + + def render_page(self, page_name: str, content: GeneratedContent, **kwargs) -> str: + """Render a complete page""" + template_name = f"{page_name}.html" + + try: + template = self.env.get_template(template_name) + except Exception: + # Fall back to base template + template = self.env.get_template("base_template.html") + + # Prepare template context + context = { + 'content': content, + 'page_name': page_name, + 'css_filename': self.css_filename, + 'site': self.config.site, + 'design_system': self.config.design_system, + 'interactions': self.config.interactions, + 'navigation': self.config.navigation, + 'seo': self.config.seo, + **kwargs + } + + return template.render(**context) + + def render_section(self, section_name: str, section_content: Any, **kwargs) -> str: + """Render an individual section""" + template_name = f"sections/{section_name}.html" + + try: + template = self.env.get_template(template_name) + except Exception as e: + print(f"Warning: Section template {template_name} not found: {e}") + return self._render_fallback_section(section_name, section_content) + + context = { + 'section': section_content, + 'config': self.config, + 'site': self.config.site, + 'design_system': self.config.design_system, + 'interactions': self.config.interactions, + 'navigation': self.config.navigation, + **kwargs + } + + return template.render(**context) + + def _render_fallback_section(self, section_name: str, content: Any) -> str: + """Render fallback HTML for section when template is missing""" + if isinstance(content, dict) and 'title' in content: + return f""" +
+
+

{content['title']}

+

Content for {section_name} section would go here.

+
+
+ """ + return f'
Section: {section_name}
' + + def generate_full_page(self, page_config: Dict[str, Any], content: GeneratedContent) -> str: + """Generate a complete HTML page with all sections""" + page_name = page_config['name'] + page_title = page_config.get('title', page_name.title()) + sections = page_config.get('sections', []) + + # Render all sections + rendered_sections = [] + for section_name in sections: + section_content = self._get_section_content(section_name, content) + if section_content: + rendered_section = self.render_section(section_name, section_content) + rendered_sections.append(rendered_section) + + # Create page context + page_context = { + 'page_title': page_title, + 'current_page': page_name, # Renamed to avoid collision + 'sections_html': '\n'.join(rendered_sections), + 'meta_description': self._generate_meta_description(content) + } + + # Render complete page + return self.render_page('index', content, **page_context) + + def _get_section_content(self, section_name: str, content: GeneratedContent) -> Optional[Any]: + """Get content for a specific section""" + section_map = { + 'revolution': content.revolution_section, + 'hero': content.hero_section, + 'overview': content.overview_section, + 'features': content.overview_section, + 'agent_showcase': content.agent_showcase, + 'agents': content.agent_showcase, + 'agent_gallery': content.agent_showcase, + 'agent_categories': content.agent_showcase, + 'workflow_examples': content.agent_showcase, + 'custom_agents': content.agent_showcase, + 'progressive_setup': content.progressive_setup, + 'progressive_tiers': content.progressive_setup, + 'quick_setup': content.progressive_setup, + 'installation': content.progressive_setup, + 'first_agent': content.progressive_setup, + 'troubleshooting': content.progressive_setup, + 'examples': content.examples_section, + 'cta': {'title': 'Get Started', 'description': 'Ready to transform your development?'} + } + + return section_map.get(section_name) + + def _generate_meta_description(self, content: GeneratedContent) -> str: + """Generate meta description from content""" + if content.hero_section: + return content.hero_section.get('description', '') + elif content.revolution_section: + return content.revolution_section.problem_statement[:160] + '...' + else: + return f"{self.config.site['name']} - {self.config.site.get('tagline', '')}" + + def create_base_templates(self): + """Create basic HTML templates if they don't exist""" + self.templates_dir.mkdir(parents=True, exist_ok=True) + sections_dir = self.templates_dir / "sections" + sections_dir.mkdir(exist_ok=True) + + # Base template + base_template = self.templates_dir / "base_template.html" + if not base_template.exists(): + base_html = self._get_base_template_html() + with open(base_template, 'w', encoding='utf-8') as f: + f.write(base_html) + + # Page templates - create for all configured pages + page_template_html = self._get_index_template_html() + for page_config in self.config.pages: + page_name = page_config['name'] + page_template = self.templates_dir / f"{page_name}.html" + if not page_template.exists(): + with open(page_template, 'w', encoding='utf-8') as f: + f.write(page_template_html) + + # Section templates + section_templates = { + 'revolution.html': self._get_revolution_section_html(), + 'hero.html': self._get_hero_section_html(), + 'agent_showcase.html': self._get_agent_showcase_html(), + 'agents.html': self._get_agent_showcase_html(), # Alias + 'agent_gallery.html': self._get_agent_showcase_html(), # Agents page sections + 'agent_categories.html': self._get_agent_showcase_html(), + 'workflow_examples.html': self._get_agent_showcase_html(), + 'custom_agents.html': self._get_agent_showcase_html(), + 'progressive_setup.html': self._get_progressive_setup_html(), + 'setup.html': self._get_progressive_setup_html(), # Alias + 'progressive_tiers.html': self._get_progressive_setup_html(), # Setup page sections + 'installation.html': self._get_progressive_setup_html(), + 'first_agent.html': self._get_progressive_setup_html(), + 'troubleshooting.html': self._get_progressive_setup_html(), + 'overview.html': self._get_overview_section_html(), # Missing sections + 'quick_setup.html': self._get_progressive_setup_html(), + 'examples.html': self._get_examples_section_html(), + 'cta.html': self._get_cta_section_html() + } + + for template_name, template_html in section_templates.items(): + template_file = sections_dir / template_name + if not template_file.exists(): + with open(template_file, 'w', encoding='utf-8') as f: + f.write(template_html) + + print(f"āœ“ Created base templates in {self.templates_dir}") + + def _get_base_template_html(self) -> str: + """Get base HTML template""" + return ''' + + + + + {{ page_title }} - {{ site.name }} + + + + + + + + + + + + + + + +
+ +
+ + +
+ {{ sections_html | safe }} +
+ + +
+
+

© {{ now().year }} {{ site.name }}. Built with Website Generator.

+
+
+ + + + +''' + + def _get_index_template_html(self) -> str: + """Get index page template (extends base)""" + return '''{% extends "base_template.html" %} + +{% block content %} +{{ sections_html | safe }} +{% endblock %}''' + + def _get_revolution_section_html(self) -> str: + """Get revolution section template""" + return '''
+
+
+

{{ section.title }}

+

{{ section.subtitle }}

+ +
+

{{ section.problem_statement }}

+
+ + {% if section.multiplier_effect %} +
+

Capability Multiplication

+
+ {% for metric in section.multiplier_effect.metrics %} +
+
{{ metric.name }}
+
+ {{ metric.old_value | format_number }} + ā†’ + + {{ metric.new_value | format_number }} + +
+
{{ metric.unit }}
+
{{ metric.multiplier }}x {% if metric.inverse %}faster{% else %}more{% endif %}
+
+ {% endfor %} +
+
+ {% endif %} + + {% if section.paradigm_comparison %} +
+

The Paradigm Shift

+
+ {% for category in section.paradigm_comparison.categories %} +
+
{{ category.name }}
+
{{ category.before }}
+
{{ category.after }}
+
{{ category.improvement }}
+
+ {% endfor %} +
+
+ {% endif %} + + {% if section.role_transformation %} +
+

Your Role Evolution

+
+
+
{{ section.role_transformation.old_role.title }}
+
    + {% for char in section.role_transformation.old_role.characteristics %} +
  • {{ char }}
    • + {% endfor %} +
+
+
ā†’
+
+
{{ section.role_transformation.new_role.title }}
+
    + {% for char in section.role_transformation.new_role.characteristics %} +
  • {{ char }}
    • + {% endfor %} +
+
+
+ {% if section.role_transformation.transformation_message %} +

{{ section.role_transformation.transformation_message }}

+ {% endif %} +
+ {% endif %} +
+
+
''' + + def _get_hero_section_html(self) -> str: + """Get hero section template""" + return '''
+
+
+

{{ section.title }}

+

{{ section.tagline }}

+

{{ section.description }}

+ + {% if section.features_preview %} +
+ {% for feature in section.features_preview %} + {{ feature }} + {% endfor %} +
+ {% endif %} + +
+ {{ section.cta_primary }} + {{ section.cta_secondary }} +
+
+
+
''' + + def _get_agent_showcase_html(self) -> str: + """Get agent showcase section template""" + return '''
+
+

+ {% if section.total_count > 20 %} + {{ section.total_count }}+ Specialized Agents + {% else %} + Specialized Agents + {% endif %} +

+

Expert AI agents handle every aspect of development

+ + {% if section.agent_categories %} +
+
+ {% for category, agents in section.agent_categories.items() %} + + {% endfor %} +
+ + {% for category, agents in section.agent_categories.items() %} +
+
+ {% for agent in agents %} +
+
+
{{ agent.name }}
+ {{ agent.category }} +
+
+

{{ agent.description }}

+ + {% if agent.capabilities %} +
+

Key Capabilities

+
    + {% for capability in agent.capabilities %} +
  • {{ capability }}
    • + {% endfor %} +
+
+ {% endif %} + + {% if agent.use_cases %} +
+

Common Use Cases

+
    + {% for use_case in agent.use_cases %} +
  • {{ use_case }}
    • + {% endfor %} +
+
+ {% endif %} + + {% if agent.example_usage %} +
+

Example Usage

+
+ 
{{ agent.example_usage }}
+
+ {% if agent.example_output %} +

{{ agent.example_output }}

+ {% endif %} +
+ {% endif %} + +
+ Advanced Details & Examples +
+
+
Integration Pattern
+

This agent integrates seamlessly with other Amplifier agents and can be used in multi-agent workflows for complex development tasks.

+
+ {% if agent.file_path %} +
+
Configuration
+

Agent definition: {{ agent.file_path }}

+
+ {% endif %} +
+
+
+
+ {% endfor %} +
+
+ {% endfor %} +
+ {% endif %} +
+
''' + + def _get_progressive_setup_html(self) -> str: + """Get progressive setup section template""" + return '''
+
+

Progressive Setup

+

Choose your learning path based on available time

+ +
+ {% for tier in section.tiers %} +
+
+

{{ tier.name }}

+ {{ tier.duration }} +
+

{{ tier.description }}

+

Focus: {{ tier.focus }}

+ + {% if tier.steps %} +
    + {% for step in tier.steps %} +
  1. {{ step }}
    2. + {% endfor %} +
+ {% endif %} + + {% if tier.demo_command %} +
+ Try this: + {{ tier.demo_command }} + {% if tier.expected_result %} +

Expected: {{ tier.expected_result }}

+ {% endif %} +
+ {% endif %} + + {% if tier.mastery_features %} +
+ What you'll master: +
    + {% for feature in tier.mastery_features %} +
  • {{ feature }}
    • + {% endfor %} +
+
+ {% endif %} + + +
+ {% endfor %} +
+
+
''' + + def _get_overview_section_html(self) -> str: + """Get overview section template""" + return '''
+
+

System Overview

+

{{ section.description | default("Understanding how Amplifier transforms development") }}

+ +
+
+
šŸŽÆ
+

Smart Agents

+

23+ specialized agents handle different aspects of development

+
+
+
āš”
+

Parallel Processing

+

Run multiple workflows simultaneously for maximum efficiency

+
+
+
šŸ”—
+

Modular Architecture

+

Clean, maintainable components that work together seamlessly

+
+
+
+
''' + + def _get_examples_section_html(self) -> str: + """Get examples section template""" + return '''
+
+

Real-World Examples

+

See Amplifier in action with practical workflows

+ +
+
+

Bug Investigation

+
+ 
Use bug-hunter to investigate database timeout errors
+
+

ā†’ Complete root cause analysis with fix recommendations

+
+ +
+

Security Review

+
+ 
Use security-guardian to review API endpoints before deployment
+
+

ā†’ Comprehensive security report with vulnerability fixes

+
+ +
+

Architecture Design

+
+ 
Use zen-architect to design a notification system
+
+

ā†’ Complete modular specification ready for implementation

+
+
+
+
''' + + def _get_cta_section_html(self) -> str: + """Get call-to-action section template""" + return '''
+
+
+

{{ section.title | default("Ready to Transform Your Development?") }}

+

{{ section.description | default("Join developers who've already experienced the paradigm shift") }}

+ +
+ Get Started + View on GitHub +
+ +

Free and open source ā€¢ No signup required ā€¢ 5 minute setup

+
+
+
''' + + +def test_template_engine(): + """Test the template engine with generated content""" + print("šŸŽØ Testing Template Engine") + print("=" * 30) + + # Load configuration + from config_loader import ConfigLoader + loader = ConfigLoader() + config = loader.load_full_config() + + # Create template engine + engine = TemplateEngine(config) + + # Create base templates + print("Creating base templates...") + engine.create_base_templates() + + # Create mock content for testing + from content.content_generator import RevolutionContent, ProgressiveSetup, AgentShowcase, GeneratedContent + + mock_revolution = RevolutionContent( + title="The Development Revolution", + subtitle="Why Amplifier Changes Everything", + problem_statement="Traditional development is slow and complex.", + paradigm_comparison={'categories': [ + {'name': 'Speed', 'before': 'Hours', 'after': 'Minutes', 'improvement': '10x faster'} + ]}, + multiplier_effect={'metrics': [ + {'name': 'Ideas', 'old_value': 50, 'new_value': 1250, 'unit': 'per month', 'multiplier': 25} + ]}, + role_transformation={ + 'old_role': {'title': 'Traditional Developer', 'characteristics': ['Code manually']}, + 'new_role': {'title': 'AI Architect', 'characteristics': ['Orchestrate agents']} + } + ) + + mock_setup = ProgressiveSetup(tiers=[ + {'name': 'Quick Taste', 'duration': '1 minute', 'description': 'Try it now', 'focus': 'First agent'} + ]) + + mock_showcase = AgentShowcase( + featured_agents=[{'name': 'zen-architect', 'description': 'System design', 'capabilities': ['architecture'], 'category': 'Architecture'}], + agent_categories={'Architecture': [{'name': 'zen-architect', 'description': 'System design', 'capabilities_count': 5}]}, + total_count=23 + ) + + mock_content = GeneratedContent( + revolution_section=mock_revolution, + progressive_setup=mock_setup, + agent_showcase=mock_showcase, + hero_section={'title': 'Amplifier', 'tagline': 'Supercharged Development', 'description': 'Transform your workflow'}, + overview_section={'title': 'Overview', 'key_points': []}, + examples_section={'title': 'Examples', 'examples': []} + ) + + # Test section rendering + print("Testing section rendering...") + revolution_html = engine.render_section('revolution', mock_revolution) + print(f"āœ“ Revolution section: {len(revolution_html)} characters") + + hero_html = engine.render_section('hero', mock_content.hero_section) + print(f"āœ“ Hero section: {len(hero_html)} characters") + + # Test full page generation + print("Testing full page generation...") + page_config = {'name': 'index', 'title': 'Home', 'sections': ['hero', 'revolution', 'agents', 'setup']} + full_html = engine.generate_full_page(page_config, mock_content) + print(f"āœ“ Full page: {len(full_html)} characters") + + # Save test output + output_dir = Path(__file__).parent.parent.parent / "output" + output_dir.mkdir(exist_ok=True) + + with open(output_dir / "test_page.html", 'w', encoding='utf-8') as f: + f.write(full_html) + + print(f"āœ“ Test page saved to: {output_dir / 'test_page.html'}") + print("āœ… Template engine test completed successfully!") + + return True + + +if __name__ == "__main__": + test_template_engine() \ No newline at end of file diff --git a/website_generator/src/style/css_generator.py b/website_generator/src/style/css_generator.py new file mode 100644 index 00000000..c82e77b0 --- /dev/null +++ b/website_generator/src/style/css_generator.py @@ -0,0 +1,1098 @@ +""" +CSS generator for website styling. +Generates CSS based on design system configuration. +""" +from pathlib import Path +from typing import Dict, Any, List +import sys + +# Import our components +sys.path.append(str(Path(__file__).parent.parent)) +from config_loader import SiteConfig + + +class CSSGenerator: + """Generates CSS from design system configuration""" + + def __init__(self, config: SiteConfig): + self.config = config + self.design_system = config.design_system + self.colors = self.design_system.get('colors', {}) + self.responsive = config.responsive + + def generate_full_css(self) -> str: + """Generate complete CSS stylesheet""" + css_parts = [ + self._generate_css_reset(), + self._generate_css_variables(), + self._generate_base_styles(), + self._generate_layout_styles(), + self._generate_component_styles(), + self._generate_section_styles(), + self._generate_responsive_styles(), + self._generate_animation_styles() + ] + + return '\n\n'.join(css_parts) + + def _generate_css_reset(self) -> str: + """Generate CSS reset and base styles""" + return '''/* CSS Reset and Base Styles */ +* { + margin: 0; + padding: 0; + box-sizing: border-box; +} + +html { + scroll-behavior: smooth; + font-size: 16px; + line-height: 1.6; +} + +body { + font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu', 'Cantarell', sans-serif; + background-color: var(--background-color); + color: var(--text-primary); + overflow-x: hidden; +} + +img { + max-width: 100%; + height: auto; +} + +a { + text-decoration: none; + color: inherit; +} + +button { + border: none; + background: none; + cursor: pointer; + font: inherit; +} + +ul, ol { + list-style: none; +}''' + + def _generate_css_variables(self) -> str: + """Generate CSS custom properties from design system""" + vars_css = "/* CSS Custom Properties */\n:root {\n" + + # Colors + for color_name, color_value in self.colors.items(): + css_name = color_name.replace('_', '-') + vars_css += f" --{css_name}: {color_value};\n" + + # Typography + if self.design_system.get('typography') == 'inter_modern': + vars_css += ''' --font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif; + --font-size-xs: 0.75rem; + --font-size-sm: 0.875rem; + --font-size-base: 1rem; + --font-size-lg: 1.125rem; + --font-size-xl: 1.25rem; + --font-size-2xl: 1.5rem; + --font-size-3xl: 1.875rem; + --font-size-4xl: 2.25rem; + --font-size-5xl: 3rem; +''' + + # Spacing + vars_css += ''' --spacing-xs: 0.25rem; + --spacing-sm: 0.5rem; + --spacing-md: 1rem; + --spacing-lg: 1.5rem; + --spacing-xl: 2rem; + --spacing-2xl: 3rem; + --spacing-3xl: 4rem; + --spacing-4xl: 6rem; +''' + + # Shadows + vars_css += ''' --shadow-sm: 0 1px 2px 0 rgba(0, 0, 0, 0.05); + --shadow: 0 1px 3px 0 rgba(0, 0, 0, 0.1), 0 1px 2px 0 rgba(0, 0, 0, 0.06); + --shadow-md: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06); + --shadow-lg: 0 10px 15px -3px rgba(0, 0, 0, 0.1), 0 4px 6px -2px rgba(0, 0, 0, 0.05); +''' + + # Border radius + vars_css += ''' --radius-sm: 0.25rem; + --radius: 0.5rem; + --radius-md: 0.75rem; + --radius-lg: 1rem; + --radius-xl: 1.5rem; +''' + + # Responsive breakpoints + if self.responsive: + breakpoints = self.responsive.get('breakpoints', {}) + for bp_name, bp_value in breakpoints.items(): + vars_css += f" --breakpoint-{bp_name}: {bp_value};\n" + + vars_css += "}" + return vars_css + + def _generate_base_styles(self) -> str: + """Generate base typography and element styles""" + return '''/* Base Typography and Elements */ +body { + font-family: var(--font-family, -apple-system, BlinkMacSystemFont, sans-serif); + font-size: var(--font-size-base); + line-height: 1.6; +} + +h1, h2, h3, h4, h5, h6 { + font-weight: 600; + line-height: 1.2; + margin-bottom: var(--spacing-md); + color: var(--text-primary); +} + +h1 { font-size: var(--font-size-4xl); } +h2 { font-size: var(--font-size-3xl); } +h3 { font-size: var(--font-size-2xl); } +h4 { font-size: var(--font-size-xl); } +h5 { font-size: var(--font-size-lg); } +h6 { font-size: var(--font-size-base); } + +p { + margin-bottom: var(--spacing-md); + color: var(--text-secondary); +} + +strong { + font-weight: 600; + color: var(--text-primary); +} + +code { + font-family: 'SF Mono', 'Monaco', 'Cascadia Code', 'Roboto Mono', monospace; + font-size: 0.875em; + background: var(--surface, #f8fafc); + padding: 0.125rem 0.25rem; + border-radius: var(--radius-sm); + border: 1px solid var(--border, #e5e7eb); +} + +pre { + background: var(--surface, #f8fafc); + padding: var(--spacing-lg); + border-radius: var(--radius); + border: 1px solid var(--border, #e5e7eb); + overflow-x: auto; + margin-bottom: var(--spacing-lg); +} + +pre code { + background: none; + padding: 0; + border: none; +}''' + + def _generate_layout_styles(self) -> str: + """Generate layout and grid styles""" + return '''/* Layout Styles */ +.container { + max-width: 1200px; + margin: 0 auto; + padding: 0 var(--spacing-lg); +} + +.section { + padding: var(--spacing-4xl) 0; +} + +.section-title { + font-size: var(--font-size-3xl); + font-weight: 700; + text-align: center; + margin-bottom: var(--spacing-lg); + color: var(--text-primary); +} + +.section-description { + font-size: var(--font-size-lg); + text-align: center; + margin-bottom: var(--spacing-3xl); + color: var(--text-secondary); + max-width: 600px; + margin-left: auto; + margin-right: auto; +} + +/* Grid Systems */ +.grid { + display: grid; + gap: var(--spacing-lg); +} + +.grid-2 { grid-template-columns: repeat(2, 1fr); } +.grid-3 { grid-template-columns: repeat(3, 1fr); } +.grid-4 { grid-template-columns: repeat(4, 1fr); } + +.flex { + display: flex; + gap: var(--spacing-md); +} + +.flex-center { + justify-content: center; + align-items: center; +} + +.flex-between { + justify-content: space-between; + align-items: center; +} + +.flex-col { + flex-direction: column; +}''' + + def _generate_component_styles(self) -> str: + """Generate component styles""" + animation_level = self.design_system.get('animation_level', 'engaging') + + # Button styles + btn_styles = '''/* Button Components */ +.btn { + display: inline-flex; + align-items: center; + justify-content: center; + padding: var(--spacing-sm) var(--spacing-lg); + font-size: var(--font-size-base); + font-weight: 500; + border-radius: var(--radius); + cursor: pointer; + text-decoration: none; + border: none; + transition: all 0.2s ease; + gap: var(--spacing-xs); +} + +.btn-primary { + background: var(--primary-color); + color: white; +} + +.btn-primary:hover { + background: var(--secondary-color); + transform: translateY(-1px); +} + +.btn-secondary { + background: transparent; + color: var(--primary-color); + border: 2px solid var(--primary-color); +} + +.btn-secondary:hover { + background: var(--primary-color); + color: white; +} + +.btn-outline { + background: transparent; + color: var(--text-primary); + border: 1px solid var(--border, #e5e7eb); +} + +.btn-outline:hover { + background: var(--surface, #f8fafc); + border-color: var(--primary-color); +}''' + + # Card styles + card_styles = ''' +/* Card Components */ +.card { + background: white; + border-radius: var(--radius-lg); + padding: var(--spacing-xl); + box-shadow: var(--shadow); + border: 1px solid var(--border, #e5e7eb); + transition: all 0.3s ease; +} + +.card:hover { + box-shadow: var(--shadow-lg); + transform: translateY(-2px); +} + +.card-header { + display: flex; + justify-content: space-between; + align-items: flex-start; + margin-bottom: var(--spacing-md); +} + +.card-title { + font-size: var(--font-size-lg); + font-weight: 600; + color: var(--text-primary); + margin: 0; +} + +.card-description { + color: var(--text-secondary); + margin-bottom: var(--spacing-md); +}''' + + # Badge styles + badge_styles = ''' +/* Badge Components */ +.badge { + display: inline-flex; + align-items: center; + padding: 0.25rem 0.75rem; + font-size: var(--font-size-sm); + font-weight: 500; + border-radius: var(--radius-xl); + text-transform: uppercase; + letter-spacing: 0.025em; +} + +.badge-architecture { + background: rgba(59, 130, 246, 0.1); + color: var(--primary-color); +} + +.badge-quality { + background: rgba(16, 185, 129, 0.1); + color: var(--success, #10b981); +} + +.badge-analysis { + background: rgba(139, 92, 246, 0.1); + color: #8b5cf6; +} + +.badge-automation { + background: rgba(245, 158, 11, 0.1); + color: var(--warning, #f59e0b); +} + +.badge-development { + background: rgba(107, 114, 128, 0.1); + color: var(--text-secondary); +}''' + + return btn_styles + card_styles + badge_styles + + def _generate_section_styles(self) -> str: + """Generate styles for specific sections""" + return '''/* Section-Specific Styles */ + +/* Header and Navigation */ +.header { + background: rgba(255, 255, 255, 0.95); + backdrop-filter: blur(10px); + border-bottom: 1px solid var(--border, #e5e7eb); + position: sticky; + top: 0; + z-index: 100; +} + +.nav { + display: flex; + justify-content: space-between; + align-items: center; + padding: var(--spacing-md) var(--spacing-lg); +} + +.nav-brand h1 { + font-size: var(--font-size-xl); + font-weight: 700; + color: var(--primary-color); + margin: 0; +} + +.nav-links { + display: flex; + gap: var(--spacing-xl); +} + +.nav-links a { + color: var(--text-secondary); + font-weight: 500; + transition: color 0.2s ease; +} + +.nav-links a:hover { + color: var(--primary-color); +} + +/* Hero Section */ +.hero-section { + background: linear-gradient(135deg, var(--primary-color) 0%, var(--secondary-color) 100%); + color: white; + text-align: center; + padding: var(--spacing-4xl) 0; +} + +.hero-title { + font-size: var(--font-size-5xl); + font-weight: 800; + margin-bottom: var(--spacing-md); +} + +.hero-tagline { + font-size: var(--font-size-xl); + margin-bottom: var(--spacing-lg); + opacity: 0.9; +} + +.hero-description { + font-size: var(--font-size-lg); + margin-bottom: var(--spacing-2xl); + max-width: 600px; + margin-left: auto; + margin-right: auto; + opacity: 0.8; +} + +.features-preview { + display: flex; + justify-content: center; + gap: var(--spacing-md); + margin-bottom: var(--spacing-2xl); + flex-wrap: wrap; +} + +.feature-badge { + background: rgba(255, 255, 255, 0.2); + padding: var(--spacing-xs) var(--spacing-md); + border-radius: var(--radius-xl); + font-size: var(--font-size-sm); + font-weight: 500; +} + +.hero-actions { + display: flex; + justify-content: center; + gap: var(--spacing-lg); +} + +/* Revolution Section */ +.revolution-section { + background: linear-gradient(135deg, #f8fafc 0%, #e2e8f0 100%); + padding: var(--spacing-4xl) 0; +} + +.revolution-title { + font-size: var(--font-size-4xl); + font-weight: 800; + text-align: center; + margin-bottom: var(--spacing-sm); + background: linear-gradient(135deg, var(--primary-color), var(--secondary-color)); + -webkit-background-clip: text; + -webkit-text-fill-color: transparent; + background-clip: text; +} + +.revolution-subtitle { + font-size: var(--font-size-xl); + text-align: center; + color: var(--text-secondary); + margin-bottom: var(--spacing-3xl); +} + +.problem-statement { + max-width: 800px; + margin: 0 auto var(--spacing-3xl); + font-size: var(--font-size-lg); + text-align: center; + color: var(--text-primary); +} + +.metrics-grid { + display: grid; + grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); + gap: var(--spacing-lg); + margin-bottom: var(--spacing-3xl); +} + +.metric-card { + background: white; + padding: var(--spacing-xl); + border-radius: var(--radius-lg); + text-align: center; + box-shadow: var(--shadow); +} + +.metric-name { + font-size: var(--font-size-sm); + text-transform: uppercase; + letter-spacing: 0.05em; + color: var(--text-secondary); + margin-bottom: var(--spacing-sm); +} + +.metric-comparison { + display: flex; + align-items: center; + justify-content: center; + gap: var(--spacing-sm); + margin-bottom: var(--spacing-xs); +} + +.old-value { + font-size: var(--font-size-lg); + color: var(--text-secondary); + text-decoration: line-through; +} + +.new-value { + font-size: var(--font-size-2xl); + font-weight: 700; + color: var(--primary-color); +} + +.arrow { + color: var(--primary-color); + font-size: var(--font-size-xl); +} + +.metric-unit { + font-size: var(--font-size-sm); + color: var(--text-secondary); + margin-bottom: var(--spacing-xs); +} + +.metric-multiplier { + font-weight: 600; + color: var(--success, #10b981); +} + +/* Agent Showcase */ +.agents-section { + padding: var(--spacing-4xl) 0; +} + +.agent-grid { + display: grid; + grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); + gap: var(--spacing-lg); + margin-bottom: var(--spacing-3xl); +} + +.agent-card { + background: white; + padding: var(--spacing-xl); + border-radius: var(--radius-lg); + box-shadow: var(--shadow); + border: 1px solid var(--border, #e5e7eb); + transition: all 0.3s ease; +} + +.agent-card:hover { + transform: translateY(-4px); + box-shadow: var(--shadow-lg); +} + +.agent-header { + display: flex; + justify-content: space-between; + align-items: flex-start; + margin-bottom: var(--spacing-md); +} + +.agent-name { + font-size: var(--font-size-lg); + font-weight: 600; + color: var(--text-primary); +} + +.agent-description { + color: var(--text-secondary); + margin-bottom: var(--spacing-md); + line-height: 1.6; +} + +.agent-capabilities { + list-style: none; + padding: 0; +} + +.agent-capabilities li { + padding: var(--spacing-xs) 0; + color: var(--text-secondary); + font-size: var(--font-size-sm); +} + +.agent-capabilities li:before { + content: "āœ“"; + color: var(--success, #10b981); + font-weight: bold; + margin-right: var(--spacing-xs); +} + +/* Rich Agent Card Styles */ +.rich-agent-card { + margin-bottom: var(--spacing-xl); + padding: var(--spacing-2xl); +} + +.rich-agent-card .agent-name { + font-size: var(--font-size-xl); + font-weight: 600; + color: var(--text-primary); +} + +.rich-agent-card .agent-category { + background: var(--primary-color); + color: white; + padding: 0.25rem 0.75rem; + border-radius: var(--radius-xl); + font-size: var(--font-size-sm); + font-weight: 500; +} + +.agent-body { + margin-top: var(--spacing-lg); +} + +.agent-features, +.agent-use-cases, +.agent-example { + margin-top: var(--spacing-lg); +} + +.agent-features h4, +.agent-use-cases h4, +.agent-example h4 { + font-size: var(--font-size-lg); + font-weight: 600; + color: var(--text-primary); + margin-bottom: var(--spacing-sm); +} + +.agent-features ul, +.agent-use-cases ul { + list-style: none; + padding-left: 0; +} + +.agent-features li, +.agent-use-cases li { + padding: var(--spacing-xs) 0; + color: var(--text-secondary); + position: relative; + padding-left: 1.5rem; +} + +.agent-features li:before, +.agent-use-cases li:before { + content: "ā€¢"; + color: var(--primary-color); + position: absolute; + left: 0; + font-weight: bold; +} + +.example-command { + background: #1e1e1e; + color: #d4d4d4; + padding: var(--spacing-md); + border-radius: var(--radius); + margin-bottom: var(--spacing-sm); + font-family: 'Consolas', 'Monaco', monospace; + font-size: 0.9rem; +} + +.example-command pre { + margin: 0; + padding: 0; + background: none; + border: none; + color: #d4d4d4; +} + +.example-output { + color: var(--success, #10b981); + font-weight: 500; + font-style: italic; +} + +.advanced-section { + margin-top: var(--spacing-lg); + border-top: 1px solid var(--border, #e5e7eb); + padding-top: var(--spacing-lg); +} + +.advanced-section summary { + cursor: pointer; + color: var(--primary-color); + font-size: 0.95rem; + margin-bottom: var(--spacing-md); + font-weight: 500; +} + +.advanced-section summary:hover { + color: var(--secondary-color); +} + +.examples-container { + margin-top: var(--spacing-md); +} + +.example-card { + background: var(--surface, #f8fafc); + padding: var(--spacing-lg); + border-radius: var(--radius); + margin-bottom: var(--spacing-md); + border: 1px solid var(--border, #e5e7eb); +} + +.example-card h5 { + color: var(--text-primary); + margin-bottom: var(--spacing-sm); + font-size: var(--font-size-base); + font-weight: 600; +} + +.example-card p { + color: var(--text-secondary); + margin: 0; + font-size: var(--font-size-sm); +} + +.example-card code { + background: var(--text-primary); + color: white; + padding: 0.125rem 0.25rem; + border-radius: 0.125rem; + font-size: 0.85em; +} + +/* Progressive Setup */ +.setup-section { + background: var(--surface, #f8fafc); + padding: var(--spacing-4xl) 0; +} + +.setup-tiers { + display: grid; + grid-template-columns: repeat(auto-fit, minmax(350px, 1fr)); + gap: var(--spacing-xl); +} + +.tier-card { + background: white; + padding: var(--spacing-2xl); + border-radius: var(--radius-lg); + box-shadow: var(--shadow); + border: 1px solid var(--border, #e5e7eb); + text-align: center; + transition: all 0.3s ease; +} + +.tier-card:hover { + transform: translateY(-4px); + box-shadow: var(--shadow-lg); +} + +.tier-header { + margin-bottom: var(--spacing-lg); +} + +.tier-name { + font-size: var(--font-size-xl); + font-weight: 700; + margin-bottom: var(--spacing-xs); +} + +.tier-duration { + background: var(--primary-color); + color: white; + padding: var(--spacing-xs) var(--spacing-md); + border-radius: var(--radius-xl); + font-size: var(--font-size-sm); + font-weight: 600; +} + +.tier-focus { + font-weight: 600; + margin-bottom: var(--spacing-lg); +} + +.tier-steps { + text-align: left; + margin-bottom: var(--spacing-lg); +} + +.tier-demo { + background: var(--surface, #f8fafc); + padding: var(--spacing-md); + border-radius: var(--radius); + margin-bottom: var(--spacing-lg); + text-align: left; +} + +.tier-demo code { + background: var(--text-primary); + color: white; + padding: var(--spacing-xs) var(--spacing-sm); + border-radius: var(--radius-sm); +} + +/* Tab System */ +.category-tabs { + display: flex; + justify-content: center; + gap: var(--spacing-sm); + margin-bottom: var(--spacing-xl); + flex-wrap: wrap; +} + +.tab-btn { + padding: var(--spacing-md) var(--spacing-lg); + background: transparent; + border: 2px solid var(--border, #e5e7eb); + border-radius: var(--radius); + cursor: pointer; + transition: all 0.2s ease; +} + +.tab-btn.active, +.tab-btn:hover { + background: var(--primary-color); + color: white; + border-color: var(--primary-color); +} + +.tab-content { + display: none; +} + +.tab-content.active { + display: block; +}''' + + def _generate_responsive_styles(self) -> str: + """Generate responsive breakpoint styles""" + mobile_bp = self.responsive.get('breakpoints', {}).get('mobile', '768px') + tablet_bp = self.responsive.get('breakpoints', {}).get('tablet', '1024px') + + return f'''/* Responsive Styles */ + +@media (max-width: {mobile_bp}) {{ + .container {{ + padding: 0 var(--spacing-md); + }} + + .section {{ + padding: var(--spacing-2xl) 0; + }} + + .hero-title {{ + font-size: var(--font-size-3xl); + }} + + .hero-actions {{ + flex-direction: column; + align-items: center; + }} + + .grid-2, + .grid-3, + .grid-4 {{ + grid-template-columns: 1fr; + }} + + .metrics-grid {{ + grid-template-columns: 1fr; + }} + + .agent-grid {{ + grid-template-columns: 1fr; + }} + + .setup-tiers {{ + grid-template-columns: 1fr; + }} + + .category-tabs {{ + flex-direction: column; + align-items: center; + }} + + .nav-links {{ + display: none; + }} +}} + +@media (max-width: {tablet_bp}) and (min-width: {mobile_bp}) {{ + .grid-3, + .grid-4 {{ + grid-template-columns: repeat(2, 1fr); + }} + + .metrics-grid {{ + grid-template-columns: repeat(2, 1fr); + }} + + .agent-grid {{ + grid-template-columns: repeat(2, 1fr); + }} +}}''' + + def _generate_animation_styles(self) -> str: + """Generate animation styles based on animation level""" + animation_level = self.design_system.get('animation_level', 'engaging') + + if animation_level == 'minimal': + return '''/* Minimal Animations */ +.btn, .card, .agent-card, .tier-card { + transition: opacity 0.2s ease; +}''' + + elif animation_level == 'subtle': + return '''/* Subtle Animations */ +.btn, .card, .agent-card, .tier-card { + transition: all 0.2s ease; +} + +.card:hover, .agent-card:hover, .tier-card:hover { + transform: translateY(-2px); +}''' + + elif animation_level == 'engaging': + return '''/* Engaging Animations */ +.btn, .card, .agent-card, .tier-card { + transition: all 0.3s ease; +} + +.card:hover, .agent-card:hover, .tier-card:hover { + transform: translateY(-4px); +} + +/* Counter Animation */ +@keyframes counter-up { + from { opacity: 0; transform: translateY(20px); } + to { opacity: 1; transform: translateY(0); } +} + +.metric-card .new-value { + animation: counter-up 0.6s ease-out; +} + +/* Fade In Animation */ +@keyframes fade-in { + from { opacity: 0; transform: translateY(30px); } + to { opacity: 1; transform: translateY(0); } +} + +.card, .agent-card, .tier-card { + animation: fade-in 0.6s ease-out; +} + +/* Hover Effects */ +.btn:hover { + transform: translateY(-2px); + box-shadow: var(--shadow-lg); +} + +.agent-card:hover .agent-name { + color: var(--primary-color); +}''' + + else: # bold + return '''/* Bold Animations */ +.btn, .card, .agent-card, .tier-card { + transition: all 0.4s cubic-bezier(0.175, 0.885, 0.32, 1.275); +} + +.card:hover, .agent-card:hover, .tier-card:hover { + transform: translateY(-8px) scale(1.02); +} + +.btn:hover { + transform: translateY(-3px) scale(1.05); +} + +/* More dramatic animations */ +@keyframes bounce-in { + 0% { opacity: 0; transform: scale(0.3); } + 50% { opacity: 1; transform: scale(1.05); } + 70% { transform: scale(0.9); } + 100% { opacity: 1; transform: scale(1); } +} + +.metric-card { + animation: bounce-in 0.6s ease-out; +}''' + + def save_css(self, output_path: str) -> None: + """Save generated CSS to file""" + css_content = self.generate_full_css() + + output_file = Path(output_path) + output_file.parent.mkdir(parents=True, exist_ok=True) + + with open(output_file, 'w', encoding='utf-8') as f: + f.write(css_content) + + print(f"āœ“ CSS saved to: {output_file} ({len(css_content):,} characters)") + + +def test_css_generator(): + """Test CSS generation""" + print("šŸŽØ Testing CSS Generator") + print("=" * 25) + + # Load configuration + from config_loader import ConfigLoader + loader = ConfigLoader() + amplifier_config_path = Path(__file__).parent.parent.parent / "examples" / "amplifier_config.yaml" + config = loader.load_full_config(str(amplifier_config_path)) + + # Generate CSS + generator = CSSGenerator(config) + + # Test individual components + print("Generating CSS components...") + reset_css = generator._generate_css_reset() + print(f"āœ“ CSS Reset: {len(reset_css)} characters") + + variables_css = generator._generate_css_variables() + print(f"āœ“ CSS Variables: {len(variables_css)} characters") + + components_css = generator._generate_component_styles() + print(f"āœ“ Component Styles: {len(components_css)} characters") + + sections_css = generator._generate_section_styles() + print(f"āœ“ Section Styles: {len(sections_css)} characters") + + responsive_css = generator._generate_responsive_styles() + print(f"āœ“ Responsive Styles: {len(responsive_css)} characters") + + animations_css = generator._generate_animation_styles() + print(f"āœ“ Animation Styles: {len(animations_css)} characters") + + # Generate full CSS + print("\nGenerating complete stylesheet...") + full_css = generator.generate_full_css() + print(f"āœ“ Complete CSS: {len(full_css):,} characters") + + # Save CSS + output_dir = Path(__file__).parent.parent.parent / "output" + output_dir.mkdir(exist_ok=True) + generator.save_css(str(output_dir / "amplifier-styles.css")) + + print("\nšŸ“Š CSS Generation Summary:") + print(f" Theme: {config.design_system['color_palette']}") + print(f" Animation Level: {config.design_system['animation_level']}") + print(f" Responsive Breakpoints: {len(config.responsive.get('breakpoints', {}))}") + print(f" Color Variables: {len(config.design_system.get('colors', {}))}") + + print("\nāœ… CSS generation test completed successfully!") + return True + + +if __name__ == "__main__": + test_css_generator() \ No newline at end of file diff --git a/website_generator/templates/base_template.html b/website_generator/templates/base_template.html new file mode 100644 index 00000000..913fee0a --- /dev/null +++ b/website_generator/templates/base_template.html @@ -0,0 +1,62 @@ + + + + + + {{ page_title }} - {{ site.name }} + + + + + + + + + + + + + + + +
+ +
+ + +
+ {{ sections_html | safe }} +
+ + +
+
+

© {{ now().year }} {{ site.name }}. Built with Website Generator.

+
+
+ + + + + \ No newline at end of file diff --git a/website_generator/templates/index.html b/website_generator/templates/index.html new file mode 100644 index 00000000..864c0aa5 --- /dev/null +++ b/website_generator/templates/index.html @@ -0,0 +1,5 @@ +{% extends "base_template.html" %} + +{% block content %} +{{ sections_html | safe }} +{% endblock %} \ No newline at end of file diff --git a/website_generator/templates/sections/agent_showcase.html b/website_generator/templates/sections/agent_showcase.html new file mode 100644 index 00000000..09e264e6 --- /dev/null +++ b/website_generator/templates/sections/agent_showcase.html @@ -0,0 +1,66 @@ +
+
+

+ {% if section.total_count > 20 %} + {{ section.total_count }}+ Specialized Agents + {% else %} + Specialized Agents + {% endif %} +

+

Expert AI agents handle every aspect of development

+ + {% if section.featured_agents %} +
+

Featured Agents

+
+ {% for agent in section.featured_agents %} +
+
+ {{ agent.name }} + {{ agent.category }} +
+

{{ agent.description }}

+ {% if agent.capabilities %} +
    + {% for capability in agent.capabilities %} +
  • {{ capability }}
    • + {% endfor %} +
+ {% endif %} +
+ {% endfor %} +
+
+ {% endif %} + + {% if section.agent_categories %} +
+

All Agents by Category

+
+ {% for category, agents in section.agent_categories.items() %} + + {% endfor %} +
+ + {% for category, agents in section.agent_categories.items() %} +
+
+ {% for agent in agents %} +
+

{{ agent.name }}

+

{{ agent.description }}

+ {% if agent.capabilities_count %} + {{ agent.capabilities_count }} capabilities + {% endif %} +
+ {% endfor %} +
+
+ {% endfor %} +
+ {% endif %} +
+
\ No newline at end of file diff --git a/website_generator/templates/sections/agents.html b/website_generator/templates/sections/agents.html new file mode 100644 index 00000000..09e264e6 --- /dev/null +++ b/website_generator/templates/sections/agents.html @@ -0,0 +1,66 @@ +
+
+

+ {% if section.total_count > 20 %} + {{ section.total_count }}+ Specialized Agents + {% else %} + Specialized Agents + {% endif %} +

+

Expert AI agents handle every aspect of development

+ + {% if section.featured_agents %} +
+

Featured Agents

+
+ {% for agent in section.featured_agents %} +
+
+ {{ agent.name }} + {{ agent.category }} +
+

{{ agent.description }}

+ {% if agent.capabilities %} +
    + {% for capability in agent.capabilities %} +
  • {{ capability }}
    • + {% endfor %} +
+ {% endif %} +
+ {% endfor %} +
+
+ {% endif %} + + {% if section.agent_categories %} +
+

All Agents by Category

+
+ {% for category, agents in section.agent_categories.items() %} + + {% endfor %} +
+ + {% for category, agents in section.agent_categories.items() %} +
+
+ {% for agent in agents %} +
+

{{ agent.name }}

+

{{ agent.description }}

+ {% if agent.capabilities_count %} + {{ agent.capabilities_count }} capabilities + {% endif %} +
+ {% endfor %} +
+
+ {% endfor %} +
+ {% endif %} +
+
\ No newline at end of file diff --git a/website_generator/templates/sections/hero.html b/website_generator/templates/sections/hero.html new file mode 100644 index 00000000..8450ec80 --- /dev/null +++ b/website_generator/templates/sections/hero.html @@ -0,0 +1,22 @@ +
+
+
+

{{ section.title }}

+

{{ section.tagline }}

+

{{ section.description }}

+ + {% if section.features_preview %} +
+ {% for feature in section.features_preview %} + {{ feature }} + {% endfor %} +
+ {% endif %} + +
+ {{ section.cta_primary }} + {{ section.cta_secondary }} +
+
+
+
\ No newline at end of file diff --git a/website_generator/templates/sections/progressive_setup.html b/website_generator/templates/sections/progressive_setup.html new file mode 100644 index 00000000..a5817d8c --- /dev/null +++ b/website_generator/templates/sections/progressive_setup.html @@ -0,0 +1,50 @@ +
+
+

Progressive Setup

+

Choose your learning path based on available time

+ +
+ {% for tier in section.tiers %} +
+
+

{{ tier.name }}

+ {{ tier.duration }} +
+

{{ tier.description }}

+

Focus: {{ tier.focus }}

+ + {% if tier.steps %} +
    + {% for step in tier.steps %} +
  1. {{ step }}
    2. + {% endfor %} +
+ {% endif %} + + {% if tier.demo_command %} +
+ Try this: + {{ tier.demo_command }} + {% if tier.expected_result %} +

Expected: {{ tier.expected_result }}

+ {% endif %} +
+ {% endif %} + + {% if tier.mastery_features %} +
+ What you'll master: +
    + {% for feature in tier.mastery_features %} +
  • {{ feature }}
    • + {% endfor %} +
+
+ {% endif %} + + +
+ {% endfor %} +
+
+
\ No newline at end of file diff --git a/website_generator/templates/sections/revolution.html b/website_generator/templates/sections/revolution.html new file mode 100644 index 00000000..89ec5d73 --- /dev/null +++ b/website_generator/templates/sections/revolution.html @@ -0,0 +1,81 @@ +
+
+
+

{{ section.title }}

+

{{ section.subtitle }}

+ +
+

{{ section.problem_statement }}

+
+ + {% if section.multiplier_effect %} +
+

Capability Multiplication

+
+ {% for metric in section.multiplier_effect.metrics %} +
+
{{ metric.name }}
+
+ {{ metric.old_value | format_number }} + ā†’ + + {{ metric.new_value | format_number }} + +
+
{{ metric.unit }}
+
{{ metric.multiplier }}x {% if metric.inverse %}faster{% else %}more{% endif %}
+
+ {% endfor %} +
+
+ {% endif %} + + {% if section.paradigm_comparison %} +
+

The Paradigm Shift

+
+ {% for category in section.paradigm_comparison.categories %} +
+
{{ category.name }}
+
{{ category.before }}
+
{{ category.after }}
+
{{ category.improvement }}
+
+ {% endfor %} +
+
+ {% endif %} + + {% if section.role_transformation %} +
+

Your Role Evolution

+
+
+
{{ section.role_transformation.old_role.title }}
+
    + {% for char in section.role_transformation.old_role.characteristics %} +
  • {{ char }}
    • + {% endfor %} +
+
+
ā†’
+
+
{{ section.role_transformation.new_role.title }}
+
    + {% for char in section.role_transformation.new_role.characteristics %} +
  • {{ char }}
    • + {% endfor %} +
+
+
+ {% if section.role_transformation.transformation_message %} +

{{ section.role_transformation.transformation_message }}

+ {% endif %} +
+ {% endif %} +
+
+
\ No newline at end of file diff --git a/website_generator/templates/sections/setup.html b/website_generator/templates/sections/setup.html new file mode 100644 index 00000000..a5817d8c --- /dev/null +++ b/website_generator/templates/sections/setup.html @@ -0,0 +1,50 @@ +
+
+

Progressive Setup

+

Choose your learning path based on available time

+ +
+ {% for tier in section.tiers %} +
+
+

{{ tier.name }}

+ {{ tier.duration }} +
+

{{ tier.description }}

+

Focus: {{ tier.focus }}

+ + {% if tier.steps %} +
    + {% for step in tier.steps %} +
  1. {{ step }}
    2. + {% endfor %} +
+ {% endif %} + + {% if tier.demo_command %} +
+ Try this: + {{ tier.demo_command }} + {% if tier.expected_result %} +

Expected: {{ tier.expected_result }}

+ {% endif %} +
+ {% endif %} + + {% if tier.mastery_features %} +
+ What you'll master: +
    + {% for feature in tier.mastery_features %} +
  • {{ feature }}
    • + {% endfor %} +
+
+ {% endif %} + + +
+ {% endfor %} +
+
+
\ No newline at end of file diff --git a/website_generator/test_complete_website.py b/website_generator/test_complete_website.py new file mode 100644 index 00000000..7873a60c --- /dev/null +++ b/website_generator/test_complete_website.py @@ -0,0 +1,308 @@ +#!/usr/bin/env python3 +""" +Test complete website generation: analyze ā†’ configure ā†’ generate content ā†’ create templates ā†’ render HTML + CSS +""" +import json +from pathlib import Path +import sys +import shutil + +# Add src to path +sys.path.append(str(Path(__file__).parent / "src")) + +from analyzer.repo_analyzer import RepositoryAnalyzer +from config_loader import ConfigLoader +from content.content_generator import ContentGenerator +from content.template_engine import TemplateEngine +from style.css_generator import CSSGenerator + + +def test_complete_website_generation(): + """Test the complete website generation pipeline""" + + print("šŸŒ Testing Complete Website Generation Pipeline") + print("=" * 60) + + output_dir = Path(__file__).parent / "output" / "amplifier_website" + output_dir.mkdir(parents=True, exist_ok=True) + + try: + # Step 1: Analyze Amplifier repository + print("1. šŸ“Š Analyzing Amplifier repository...") + repo_path = "/mnt/c/Users/samschillace/amplifier" + analyzer = RepositoryAnalyzer(repo_path) + analysis = analyzer.analyze_repository() + + print(f" āœ“ Detected paradigm: {analysis.paradigm_type.value}") + print(f" āœ“ Found {len(analysis.agents)} agents") + print(f" āœ“ Found {len(analysis.commands)} commands") + print(f" āœ“ Complexity score: {analysis.complexity_score}") + + # Step 2: Load configuration + print("\n2. āš™ļø Loading configuration...") + loader = ConfigLoader() + amplifier_config_path = Path(__file__).parent / "examples" / "amplifier_config.yaml" + config = loader.load_full_config(str(amplifier_config_path)) + + print(f" āœ“ Site name: {config.site['name']}") + print(f" āœ“ Theme: {config.site['theme']}") + print(f" āœ“ Pages to generate: {len(config.pages)}") + + # Step 3: Generate content + print("\n3. šŸ“ Generating website content...") + content_generator = ContentGenerator(config) + content = content_generator.generate_content(analysis) + + print(f" āœ“ Revolution section: {content.revolution_section.title}") + print(f" āœ“ Setup tiers: {len(content.progressive_setup.tiers)}") + print(f" āœ“ Agent showcase: {content.agent_showcase.total_count} agents") + print(f" āœ“ Hero section: {content.hero_section['title']}") + + # Step 4: Initialize template engine + print("\n4. šŸŽØ Setting up template engine...") + templates_dir = output_dir / "templates" + css_filename = "amplifier-styles.css" + template_engine = TemplateEngine(config, str(templates_dir), css_filename) + template_engine.create_base_templates() + + print(f" āœ“ Templates created in: {templates_dir}") + + # Step 5: Generate CSS + print("\n5. šŸŽØ Generating CSS stylesheet...") + css_generator = CSSGenerator(config) + css_path = output_dir / "amplifier-styles.css" + css_generator.save_css(str(css_path)) + + # Step 6: Generate HTML pages + print("\n6. šŸ“„ Generating HTML pages...") + + for page_config in config.pages: + page_name = page_config['name'] + print(f" Generating {page_name}.html...") + + # Generate HTML for this page + html_content = template_engine.generate_full_page(page_config, content) + + # Save HTML file + html_path = output_dir / f"{page_name}.html" + with open(html_path, 'w', encoding='utf-8') as f: + f.write(html_content) + + print(f" āœ“ {page_name}.html ({len(html_content):,} characters)") + + # Step 7: Create additional assets + print("\n7. šŸ“ Creating additional assets...") + + # Create basic JavaScript file + js_content = '''// Basic website JavaScript +document.addEventListener('DOMContentLoaded', function() { + console.log('Amplifier website loaded'); + + // Tab functionality + window.showTab = function(tabId, buttonElement) { + // Hide all tab contents + const tabContents = document.querySelectorAll('.tab-content'); + tabContents.forEach(content => content.classList.remove('active')); + + // Remove active class from all buttons + const tabBtns = document.querySelectorAll('.tab-btn'); + tabBtns.forEach(btn => btn.classList.remove('active')); + + // Show selected tab and mark button as active + const targetTab = document.getElementById(tabId); + if (targetTab) { + targetTab.classList.add('active'); + } + + if (buttonElement) { + buttonElement.classList.add('active'); + } + }; + + // Counter animation + const animateCounters = () => { + const counters = document.querySelectorAll('[data-counter]'); + counters.forEach(counter => { + const target = parseInt(counter.getAttribute('data-counter')); + const duration = 2000; + const start = performance.now(); + + const updateCounter = (currentTime) => { + const elapsed = currentTime - start; + const progress = Math.min(elapsed / duration, 1); + const easeOut = 1 - Math.pow(1 - progress, 3); + const current = Math.floor(target * easeOut); + + counter.textContent = current.toLocaleString(); + + if (progress < 1) { + requestAnimationFrame(updateCounter); + } + }; + + requestAnimationFrame(updateCounter); + }); + }; + + // Trigger counter animation when revolution section is visible + const revolutionSection = document.getElementById('revolution'); + if (revolutionSection) { + const observer = new IntersectionObserver((entries) => { + entries.forEach(entry => { + if (entry.isIntersecting) { + animateCounters(); + observer.unobserve(entry.target); + } + }); + }, { threshold: 0.5 }); + + observer.observe(revolutionSection); + } + + // Smooth scrolling for navigation links + const navLinks = document.querySelectorAll('a[href^="#"]'); + navLinks.forEach(link => { + link.addEventListener('click', function(e) { + e.preventDefault(); + const targetId = this.getAttribute('href'); + const targetElement = document.querySelector(targetId); + + if (targetElement) { + const headerHeight = 80; // Approximate header height + const targetPosition = targetElement.offsetTop - headerHeight; + + window.scrollTo({ + top: targetPosition, + behavior: 'smooth' + }); + } + }); + }); +});''' + + js_path = output_dir / "script.js" + with open(js_path, 'w', encoding='utf-8') as f: + f.write(js_content) + print(f" āœ“ script.js ({len(js_content):,} characters)") + + # Create a simple README for the generated website + readme_content = f'''# Generated Amplifier Website + +This website was automatically generated using the Website Generator tool. + +## Generated Files + +- `index.html` - Main homepage +- `setup.html` - Setup and installation guide +- `agents.html` - Agent showcase +- `amplifier-styles.css` - Complete stylesheet +- `script.js` - Interactive JavaScript + +## Site Information + +- **Project**: {config.site['name']} +- **Theme**: {config.site['theme']} +- **Paradigm Type**: {analysis.paradigm_type.value} +- **Agents**: {len(analysis.agents)} +- **Commands**: {len(analysis.commands)} +- **Complexity Score**: {analysis.complexity_score} + +## Generation Summary + +- **Revolution Section**: āœ“ Generated with capability multipliers +- **Progressive Setup**: āœ“ {len(content.progressive_setup.tiers)} tiers +- **Agent Showcase**: āœ“ {content.agent_showcase.total_count} agents in {len(content.agent_showcase.agent_categories)} categories +- **Responsive Design**: āœ“ Mobile, tablet, desktop breakpoints +- **Animations**: āœ“ {config.design_system['animation_level']} level animations + +## View the Website + +1. Open `index.html` in a web browser +2. Or serve with a local server: + ```bash + python -m http.server 8000 + ``` + +Generated on {content.hero_section.get('title', 'Unknown Date')} +''' + + readme_path = output_dir / "README.md" + with open(readme_path, 'w', encoding='utf-8') as f: + f.write(readme_content) + print(f" āœ“ README.md") + + # Step 8: Generate summary report + print("\n8. šŸ“‹ Generating summary report...") + + summary_report = { + "generation_info": { + "timestamp": "2025-01-24", + "repository_analyzed": repo_path, + "config_used": str(amplifier_config_path) + }, + "analysis_results": { + "paradigm_type": analysis.paradigm_type.value, + "agents_found": len(analysis.agents), + "commands_found": len(analysis.commands), + "complexity_score": analysis.complexity_score, + "paradigm_indicators": analysis.paradigm_indicators + }, + "content_generated": { + "has_revolution_section": content.revolution_section is not None, + "setup_tiers": len(content.progressive_setup.tiers), + "featured_agents": len(content.agent_showcase.featured_agents), + "agent_categories": list(content.agent_showcase.agent_categories.keys()), + "total_agents": content.agent_showcase.total_count + }, + "files_generated": { + "html_pages": len(config.pages), + "css_file": "amplifier-styles.css", + "js_file": "script.js", + "templates_created": True, + "readme_included": True + } + } + + report_path = output_dir / "generation_report.json" + with open(report_path, 'w', encoding='utf-8') as f: + json.dump(summary_report, f, indent=2, ensure_ascii=False) + + print(f" āœ“ generation_report.json") + + # Final summary + print(f"\nāœ… Complete website generation successful!") + print("=" * 60) + print(f"šŸ“ Output directory: {output_dir}") + print(f"šŸŒ Website files generated:") + + for file_path in output_dir.rglob("*"): + if file_path.is_file(): + rel_path = file_path.relative_to(output_dir) + size = file_path.stat().st_size + print(f" ā€¢ {rel_path} ({size:,} bytes)") + + print(f"\nšŸš€ To view the website:") + print(f" 1. cd {output_dir}") + print(f" 2. python -m http.server 8000") + print(f" 3. Open http://localhost:8000") + + print(f"\nšŸŽÆ Key Features Generated:") + if content.revolution_section: + print(f" ā€¢ Revolution section with {len(content.revolution_section.multiplier_effect['metrics'])} capability multipliers") + print(f" ā€¢ Role transformation: {content.revolution_section.role_transformation['old_role']['title']} ā†’ {content.revolution_section.role_transformation['new_role']['title']}") + print(f" ā€¢ Progressive setup with {len(content.progressive_setup.tiers)} tiers") + print(f" ā€¢ {content.agent_showcase.total_count} agents organized into {len(content.agent_showcase.agent_categories)} categories") + print(f" ā€¢ Responsive design with {len(config.responsive.get('breakpoints', {}))} breakpoints") + print(f" ā€¢ {config.design_system['animation_level']} level animations") + + return True + + except Exception as e: + print(f"āŒ Website generation failed: {e}") + import traceback + traceback.print_exc() + return False + + +if __name__ == "__main__": + test_complete_website_generation() \ No newline at end of file diff --git a/website_generator/test_full_generation.py b/website_generator/test_full_generation.py new file mode 100644 index 00000000..9ffe1a6a --- /dev/null +++ b/website_generator/test_full_generation.py @@ -0,0 +1,140 @@ +#!/usr/bin/env python3 +""" +Test full content generation pipeline with real Amplifier data. +""" +import json +from pathlib import Path +import sys + +# Add src to path +sys.path.append(str(Path(__file__).parent / "src")) + +from analyzer.repo_analyzer import RepositoryAnalyzer +from config_loader import ConfigLoader +from content.content_generator import ContentGenerator + + +def test_full_pipeline(): + """Test the complete pipeline: analyze ā†’ configure ā†’ generate content""" + + print("šŸš€ Testing Full Website Generation Pipeline") + print("=" * 50) + + # Step 1: Analyze Amplifier repository + print("1. Analyzing Amplifier repository...") + repo_path = "/mnt/c/Users/samschillace/amplifier" + analyzer = RepositoryAnalyzer(repo_path) + analysis = analyzer.analyze_repository() + + print(f" āœ“ Found {len(analysis.agents)} agents") + print(f" āœ“ Found {len(analysis.commands)} commands") + print(f" āœ“ Paradigm type: {analysis.paradigm_type.value}") + print(f" āœ“ Complexity score: {analysis.complexity_score}") + + # Step 2: Load configuration + print("\n2. Loading configuration...") + loader = ConfigLoader() + amplifier_config_path = Path(__file__).parent / "examples" / "amplifier_config.yaml" + config = loader.load_full_config(str(amplifier_config_path)) + + print(f" āœ“ Loaded config for: {config.site['name']}") + print(f" āœ“ Theme: {config.site['theme']}") + print(f" āœ“ Pages: {len(config.pages)}") + + # Step 3: Generate content + print("\n3. Generating website content...") + generator = ContentGenerator(config) + content = generator.generate_content(analysis) + + print(f" āœ“ Generated revolution section: {content.revolution_section.title}") + print(f" āœ“ Created {len(content.progressive_setup.tiers)} setup tiers") + print(f" āœ“ Showcased {content.agent_showcase.total_count} agents") + print(f" āœ“ Agent categories: {list(content.agent_showcase.agent_categories.keys())}") + + # Step 4: Display sample generated content + print("\n4. Sample Generated Content:") + print("-" * 30) + + if content.revolution_section: + print(f"šŸŽÆ Revolution Section:") + print(f" Title: {content.revolution_section.title}") + print(f" Subtitle: {content.revolution_section.subtitle}") + print(f" Problem: {content.revolution_section.problem_statement[:100]}...") + + # Show multiplier effects + print(f"\nšŸ“Š Capability Multipliers:") + for metric in content.revolution_section.multiplier_effect['metrics']: + if metric.get('inverse'): + print(f" ā€¢ {metric['name']}: {metric['old_value']} ā†’ {metric['new_value']} {metric['unit']} ({metric['multiplier']}x faster)") + else: + print(f" ā€¢ {metric['name']}: {metric['old_value']} ā†’ {metric['new_value']} {metric['unit']} ({metric['multiplier']}x)") + + print(f"\nšŸ—ļø Progressive Setup:") + for i, tier in enumerate(content.progressive_setup.tiers, 1): + print(f" {i}. {tier['name']} ({tier['duration']})") + print(f" Focus: {tier['focus']}") + if 'demo_command' in tier: + print(f" Demo: {tier['demo_command']}") + + print(f"\nšŸ¤– Agent Showcase:") + print(f" Total agents: {content.agent_showcase.total_count}") + for category, agents in content.agent_showcase.agent_categories.items(): + print(f" {category}: {len(agents)} agents") + + print(f"\nšŸŽØ Hero Section:") + hero = content.hero_section + print(f" Title: {hero['title']}") + print(f" Tagline: {hero['tagline']}") + print(f" Features: {', '.join(hero['features_preview'])}") + + # Step 5: Export analysis and content for inspection + print("\n5. Exporting results...") + + # Save analysis + analysis_output = Path(__file__).parent / "output" / "amplifier_analysis.json" + analysis_output.parent.mkdir(exist_ok=True) + analyzer.save_analysis(analysis, str(analysis_output)) + + # Save generated content as JSON for inspection + content_output = Path(__file__).parent / "output" / "generated_content.json" + content_dict = { + "revolution_section": { + "title": content.revolution_section.title, + "subtitle": content.revolution_section.subtitle, + "problem_statement": content.revolution_section.problem_statement, + "paradigm_comparison": content.revolution_section.paradigm_comparison, + "multiplier_effect": content.revolution_section.multiplier_effect, + "role_transformation": content.revolution_section.role_transformation + } if content.revolution_section else None, + "progressive_setup": { + "tiers": content.progressive_setup.tiers + }, + "agent_showcase": { + "featured_agents": content.agent_showcase.featured_agents, + "agent_categories": content.agent_showcase.agent_categories, + "total_count": content.agent_showcase.total_count + }, + "hero_section": content.hero_section, + "overview_section": content.overview_section, + "examples_section": content.examples_section + } + + with open(content_output, 'w', encoding='utf-8') as f: + json.dump(content_dict, f, indent=2, ensure_ascii=False) + + print(f" āœ“ Analysis saved to: {analysis_output}") + print(f" āœ“ Content saved to: {content_output}") + + print(f"\nāœ… Full pipeline test completed successfully!") + print(f"šŸ“ Check the output/ directory for detailed results") + + return True + + +if __name__ == "__main__": + try: + test_full_pipeline() + except Exception as e: + print(f"āŒ Pipeline test failed: {e}") + import traceback + traceback.print_exc() \ No newline at end of file From f3f92dac17fe6d305bc7fabbdf4a72bc58b535b3 Mon Sep 17 00:00:00 2001 From: Claude Code Date: Fri, 26 Sep 2025 13:37:14 -0700 Subject: [PATCH 3/3] feat: implement shared ideas management system with AI-powered operations MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Add comprehensive ideas management system with natural language goals, per-person assignment queues, and LLM operations. System follows hybrid code/AI architecture with reliable structure and AI intelligence. Core features: - Pydantic models with type-safe data structures - YAML storage with defensive file I/O patterns - Click-based CLI with rich formatting and table output - LLM operations: goal-based reordering, theme detection, similarity analysis - Makefile integration with 15+ make commands (ideas-add, ideas-list, etc) - Natural language slash command (/ideas) for conversational interface - Defensive patterns for cloud sync (OneDrive/Dropbox) resilience - Per-user assignment queues with automatic ranking - Strategic goal management for priority alignment Technical implementation: - Follows amplifier patterns and modular design philosophy - Uses defensive file I/O with retry logic and atomic operations - Mock LLM implementations showing ccsdk_toolkit integration patterns - Rich console output with tables and progress indicators - Comprehensive error handling and user feedback - FileLock for concurrent access protection šŸ¤– Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude --- .claude/commands/ideas.md | 58 ++++ Makefile | 73 ++++- amplifier/ideas/__init__.py | 9 + amplifier/ideas/cli.py | 483 ++++++++++++++++++++++++++++++++++ amplifier/ideas/models.py | 168 ++++++++++++ amplifier/ideas/operations.py | 337 ++++++++++++++++++++++++ amplifier/ideas/storage.py | 237 +++++++++++++++++ 7 files changed, 1364 insertions(+), 1 deletion(-) create mode 100644 .claude/commands/ideas.md create mode 100644 amplifier/ideas/__init__.py create mode 100644 amplifier/ideas/cli.py create mode 100644 amplifier/ideas/models.py create mode 100644 amplifier/ideas/operations.py create mode 100644 amplifier/ideas/storage.py diff --git a/.claude/commands/ideas.md b/.claude/commands/ideas.md new file mode 100644 index 00000000..f5edf87b --- /dev/null +++ b/.claude/commands/ideas.md @@ -0,0 +1,58 @@ +--- +allowed-tools: Bash(make:*), Bash(uv:*), Bash(python:*) +argument-hint: [natural language request about ideas management] +description: Natural language interface to the shared ideas management system +--- + +# Ideas Management Assistant + +You are helping with the shared ideas management system. The user's request is: $ARGUMENTS + +## Available Operations + +The ideas management system supports these operations through make commands: + +### Basic Operations +- `make ideas-status` - Show collection status and statistics +- `make ideas-list` - List all ideas +- `make ideas-list-unassigned` - Show unassigned ideas only +- `make ideas-add IDEA="title" DESCRIPTION="desc" [PRIORITY=high/medium/low] [THEMES="theme1,theme2"] [ASSIGNEE=user]` - Add new idea +- `make ideas-assign ID="idea_id" ASSIGNEE="user"` - Assign idea to user +- `make ideas-remove ID="idea_id"` - Remove an idea +- `make ideas-show ID="idea_id"` - Show detailed info about an idea + +### User Queues +- `make ideas-user-queue USER="username"` - Show ideas assigned to specific user + +### Goals Management +- `make ideas-add-goal DESCRIPTION="goal description" [PRIORITY=1]` - Add strategic goal +- `make ideas-goals` - List active goals + +### AI-Powered Operations +- `make ideas-reorder` - Reorder ideas based on active goals using AI +- `make ideas-themes` - Detect common themes across ideas using AI +- `make ideas-similar ID="idea_id"` - Find similar ideas using AI +- `make ideas-optimize` - Optimize idea order for maximum leverage using AI + +### File Operations +- `make ideas-init [SAMPLE=true]` - Initialize new ideas file +- Uses `~/amplifier/ideas.yaml` by default, or specify with `IDEAS_FILE="/path/to/file.yaml"` + +## Your Task + +Based on the user's request "$ARGUMENTS", determine what they want to do and execute the appropriate commands. Handle the request naturally and conversationally. + +**IMPORTANT**: If any command fails because the ideas file doesn't exist, automatically run `make ideas-init` first to create it, then retry the original command. + +For example: +- "add a new idea about improving performance" ā†’ use ideas-add with appropriate parameters +- "show me my ideas" ā†’ first ask who they are, then use ideas-user-queue +- "what themes do we have?" ā†’ use ideas-themes +- "reorder based on our goals" ā†’ use ideas-reorder (after ensuring goals exist) +- "optimize our priorities" ā†’ use ideas-optimize +- "show me similar ideas to xyz" ā†’ find the ID first, then use ideas-similar +- "make an ideas file" or "initialize" or "setup" ā†’ use ideas-init +- "status" or "what's the current state" ā†’ use ideas-status +- "list ideas" or "show ideas" ā†’ use ideas-list + +Always explain what you're doing and provide clear, helpful responses about the results. Be proactive about creating the ideas file if it doesn't exist. \ No newline at end of file diff --git a/Makefile b/Makefile index da372af1..0acab702 100644 --- a/Makefile +++ b/Makefile @@ -164,7 +164,7 @@ check: ## Format, lint, and type-check all code @echo "Linting code with ruff..." @VIRTUAL_ENV= uv run ruff check . --fix @echo "Type-checking code with pyright..." - @VIRTUAL_ENV= uv run pyright + @npx pyright @echo "Checking for stubs and placeholders..." @python tools/check_stubs.py @echo "All checks passed!" @@ -483,3 +483,74 @@ workspace-info: ## Show workspace information @echo "" $(call list_projects) @echo "" + +# Ideas Management +ideas-init: ## Initialize ideas file with sample data + @echo "Initializing ideas file..." + uv run python -m amplifier.ideas.cli init --sample + +ideas-add: ## Add a new idea. Usage: make ideas-add IDEA="title" [DESCRIPTION="desc"] [ASSIGNEE="user"] [PRIORITY="high|medium|low"] [THEMES="theme1,theme2"] + @if [ -z "$(IDEA)" ]; then \ + echo "Error: Please provide an idea title. Usage: make ideas-add IDEA=\"Build caching layer\""; \ + exit 1; \ + fi + @cmd="uv run python -m amplifier.ideas.cli add \"$(IDEA)\""; \ + if [ -n "$(DESCRIPTION)" ]; then cmd="$$cmd --description \"$(DESCRIPTION)\""; fi; \ + if [ -n "$(ASSIGNEE)" ]; then cmd="$$cmd --assignee \"$(ASSIGNEE)\""; fi; \ + if [ -n "$(PRIORITY)" ]; then cmd="$$cmd --priority \"$(PRIORITY)\""; fi; \ + if [ -n "$(THEMES)" ]; then \ + for theme in $$(echo "$(THEMES)" | tr ',' ' '); do \ + cmd="$$cmd --themes \"$$theme\""; \ + done; \ + fi; \ + eval $$cmd + +ideas-list: ## List ideas with optional filters. Usage: make ideas-list [USER="alice"] [PRIORITY="high"] [THEME="ui"] + @cmd="uv run python -m amplifier.ideas.cli list"; \ + if [ -n "$(USER)" ]; then cmd="$$cmd --user \"$(USER)\""; fi; \ + if [ "$(UNASSIGNED)" = "true" ]; then cmd="$$cmd --unassigned"; fi; \ + if [ -n "$(PRIORITY)" ]; then cmd="$$cmd --priority \"$(PRIORITY)\""; fi; \ + if [ -n "$(THEME)" ]; then cmd="$$cmd --theme \"$(THEME)\""; fi; \ + eval $$cmd + +ideas-assign: ## Assign an idea to a user. Usage: make ideas-assign IDEA_ID="idea_123" USER="alice" + @if [ -z "$(IDEA_ID)" ] || [ -z "$(USER)" ]; then \ + echo "Error: Please provide both IDEA_ID and USER. Usage: make ideas-assign IDEA_ID=\"idea_123\" USER=\"alice\""; \ + exit 1; \ + fi + uv run python -m amplifier.ideas.cli assign "$(IDEA_ID)" "$(USER)" + +ideas-status: ## Show ideas collection status and statistics + uv run python -m amplifier.ideas.cli status + +ideas-goals: ## List active goals for idea prioritization + uv run python -m amplifier.ideas.cli goals + +ideas-add-goal: ## Add a new goal. Usage: make ideas-add-goal GOAL="Focus on user experience" + @if [ -z "$(GOAL)" ]; then \ + echo "Error: Please provide a goal description. Usage: make ideas-add-goal GOAL=\"Focus on user experience\""; \ + exit 1; \ + fi + @cmd="uv run python -m amplifier.ideas.cli add-goal \"$(GOAL)\""; \ + if [ -n "$(PRIORITY)" ]; then cmd="$$cmd --priority $(PRIORITY)"; fi; \ + eval $$cmd + +ideas-reorder: ## Reorder ideas based on active goals using AI + @echo "šŸŽÆ Reordering ideas based on goals..." + uv run python -m amplifier.ideas.cli reorder + +ideas-themes: ## Detect common themes across ideas using AI + @echo "šŸ” Detecting themes in ideas..." + uv run python -m amplifier.ideas.cli themes + +ideas-similar: ## Find similar ideas. Usage: make ideas-similar IDEA_ID="idea_123" + @if [ -z "$(IDEA_ID)" ]; then \ + echo "Error: Please provide IDEA_ID. Usage: make ideas-similar IDEA_ID=\"idea_123\""; \ + exit 1; \ + fi + @echo "šŸ”Ž Finding similar ideas..." + uv run python -m amplifier.ideas.cli similar "$(IDEA_ID)" + +ideas-optimize: ## Optimize idea order for maximum leverage using AI + @echo "āš” Optimizing ideas for leverage..." + uv run python -m amplifier.ideas.cli optimize diff --git a/amplifier/ideas/__init__.py b/amplifier/ideas/__init__.py new file mode 100644 index 00000000..d7e80dbd --- /dev/null +++ b/amplifier/ideas/__init__.py @@ -0,0 +1,9 @@ +""" +Shared Ideas Management System + +A hybrid code/AI system for managing project ideas with natural language goals, +per-person assignment queues, and LLM-powered operations like reordering and theme detection. +""" + +__version__ = "1.0.0" +__all__ = ["storage", "operations", "cli", "models"] diff --git a/amplifier/ideas/cli.py b/amplifier/ideas/cli.py new file mode 100644 index 00000000..9795a06d --- /dev/null +++ b/amplifier/ideas/cli.py @@ -0,0 +1,483 @@ +""" +Click-based CLI interface for the ideas management system. + +Provides command-line access to all ideas operations following +Amplifier's conventions and patterns. +""" + +import asyncio +import sys +from pathlib import Path + +import click +from rich.console import Console +from rich.table import Table + +from amplifier.ideas.models import Goal +from amplifier.ideas.models import Idea +from amplifier.ideas.storage import IdeasStorage +from amplifier.ideas.storage import get_default_ideas_file + +console = Console() + + +@click.group() +@click.option( + "--file", "-f", "ideas_file", type=click.Path(), help="Path to ideas YAML file (default: ~/amplifier/ideas.yaml)" +) +@click.pass_context +def ideas(ctx: click.Context, ideas_file: str | None) -> None: + """ + Amplifier Ideas Management System + + Manage shared project ideas with goals, assignments, and AI-powered operations. + """ + ctx.ensure_object(dict) + + # Determine ideas file path + if ideas_file: + ctx.obj["ideas_file"] = Path(ideas_file) + else: + ctx.obj["ideas_file"] = get_default_ideas_file() + + ctx.obj["storage"] = IdeasStorage(ctx.obj["ideas_file"]) + + +@ideas.command() +@click.argument("title") +@click.option("--description", "-d", default="", help="Idea description") +@click.option("--assignee", "-a", help="Assign to user") +@click.option("--priority", "-p", type=click.Choice(["high", "medium", "low"]), default="medium", help="Idea priority") +@click.option("--themes", "-t", multiple=True, help="Themes/tags (can use multiple times)") +@click.option("--notes", "-n", help="Additional notes") +@click.pass_context +def add( + ctx: click.Context, + title: str, + description: str, + assignee: str | None, + priority: str, + themes: tuple[str], + notes: str | None, +) -> None: + """Add a new idea to the collection""" + + storage: IdeasStorage = ctx.obj["storage"] + doc = storage.load() + + # Create new idea + idea = Idea(title=title, description=description, themes=list(themes), priority=priority, notes=notes) + + # Add to document + doc.add_idea(idea) + + # Assign if specified + if assignee: + doc.assign_idea(idea.id, assignee) + + # Save + storage.save(doc) + + console.print(f"āœ… Added idea: [bold]{title}[/bold]") + if assignee: + console.print(f" Assigned to: {assignee}") + console.print(f" ID: {idea.id}") + + +@ideas.command(name="list") +@click.option("--user", "-u", help="Filter by assigned user") +@click.option("--unassigned", is_flag=True, help="Show only unassigned ideas") +@click.option("--priority", "-p", type=click.Choice(["high", "medium", "low"]), help="Filter by priority") +@click.option("--theme", "-t", help="Filter by theme") +@click.option("--limit", "-l", type=int, default=20, help="Limit number of results") +@click.pass_context +def list_ideas( + ctx: click.Context, user: str | None, unassigned: bool, priority: str | None, theme: str | None, limit: int +) -> None: + """List ideas with optional filters""" + + storage: IdeasStorage = ctx.obj["storage"] + doc = storage.load() + + # Apply filters + if user: + ideas_list = doc.get_user_queue(user) + title = f"Ideas assigned to {user}" + elif unassigned: + ideas_list = doc.get_unassigned() + title = "Unassigned ideas" + else: + ideas_list = doc.ideas + title = "All ideas" + + if priority: + ideas_list = [i for i in ideas_list if i.priority == priority] + + if theme: + ideas_list = [i for i in ideas_list if theme.lower() in [t.lower() for t in i.themes]] + + # Apply limit + ideas_list = ideas_list[:limit] + + if not ideas_list: + console.print("No ideas found matching criteria") + return + + # Create table + table = Table(title=title) + table.add_column("ID", style="dim") + table.add_column("Title", style="bold") + table.add_column("Assignee") + table.add_column("Priority") + table.add_column("Themes", style="dim") + + for idea in ideas_list: + assignee = idea.assignee or "[dim]unassigned[/dim]" + priority_style = {"high": "[red]high[/red]", "medium": "[yellow]medium[/yellow]", "low": "[green]low[/green]"} + priority_text = priority_style.get(idea.priority, idea.priority) + themes_text = ", ".join(idea.themes) if idea.themes else "" + + table.add_row(idea.id, idea.title, assignee, priority_text, themes_text) + + console.print(table) + console.print(f"\nShowing {len(ideas_list)} ideas") + + +@ideas.command() +@click.argument("idea_id") +@click.argument("assignee") +@click.pass_context +def assign(ctx: click.Context, idea_id: str, assignee: str) -> None: + """Assign an idea to a user""" + + storage: IdeasStorage = ctx.obj["storage"] + doc = storage.load() + + if doc.assign_idea(idea_id, assignee): + storage.save(doc) + idea = doc.find_idea(idea_id) + console.print(f"āœ… Assigned '[bold]{idea.title}[/bold]' to {assignee}") + else: + console.print(f"āŒ Idea not found: {idea_id}", err=True) + sys.exit(1) + + +@ideas.command() +@click.argument("idea_id") +@click.pass_context +def remove(ctx: click.Context, idea_id: str) -> None: + """Remove an idea from the collection""" + + storage: IdeasStorage = ctx.obj["storage"] + doc = storage.load() + + idea = doc.find_idea(idea_id) + if not idea: + console.print(f"āŒ Idea not found: {idea_id}", err=True) + sys.exit(1) + + if doc.remove_idea(idea_id): + storage.save(doc) + console.print(f"āœ… Removed idea: [bold]{idea.title}[/bold]") + else: + console.print(f"āŒ Failed to remove idea: {idea_id}", err=True) + sys.exit(1) + + +@ideas.command() +@click.argument("idea_id") +@click.pass_context +def show(ctx: click.Context, idea_id: str) -> None: + """Show detailed information about an idea""" + + storage: IdeasStorage = ctx.obj["storage"] + doc = storage.load() + + idea = doc.find_idea(idea_id) + if not idea: + console.print(f"āŒ Idea not found: {idea_id}", err=True) + sys.exit(1) + + # Display detailed info + console.print(f"\n[bold]{idea.title}[/bold]") + console.print(f"ID: {idea.id}") + console.print(f"Priority: {idea.priority}") + console.print(f"Assignee: {idea.assignee or 'unassigned'}") + console.print(f"Created: {idea.created.strftime('%Y-%m-%d %H:%M')}") + console.print(f"Modified: {idea.modified.strftime('%Y-%m-%d %H:%M')}") + + if idea.themes: + console.print(f"Themes: {', '.join(idea.themes)}") + + if idea.description: + console.print(f"\nDescription:\n{idea.description}") + + if idea.notes: + console.print(f"\nNotes:\n{idea.notes}") + + +@ideas.command("add-goal") +@click.argument("description") +@click.option("--priority", "-p", type=int, default=1, help="Goal priority (lower = higher)") +@click.pass_context +def add_goal(ctx: click.Context, description: str, priority: int) -> None: + """Add a new goal for idea prioritization""" + + storage: IdeasStorage = ctx.obj["storage"] + doc = storage.load() + + goal = Goal(description=description, priority=priority) + doc.add_goal(goal) + + storage.save(doc) + console.print(f"āœ… Added goal: [bold]{description}[/bold]") + console.print(f" Priority: {priority}") + console.print(f" ID: {goal.id}") + + +@ideas.command() +@click.pass_context +def goals(ctx: click.Context) -> None: + """List all active goals""" + + storage: IdeasStorage = ctx.obj["storage"] + doc = storage.load() + + active_goals = doc.get_active_goals() + + if not active_goals: + console.print("No active goals") + return + + table = Table(title="Active Goals") + table.add_column("Priority", style="bold") + table.add_column("Description") + table.add_column("Created") + + for goal in active_goals: + table.add_row(str(goal.priority), goal.description, goal.created.strftime("%Y-%m-%d")) + + console.print(table) + + +@ideas.command() +@click.pass_context +def status(ctx: click.Context) -> None: + """Show overall status of ideas collection""" + + storage: IdeasStorage = ctx.obj["storage"] + doc = storage.load() + + # Gather statistics + total_ideas = len(doc.ideas) + assigned = len([i for i in doc.ideas if i.is_assigned()]) + unassigned = len(doc.get_unassigned()) + + high_priority = len(doc.get_by_priority("high")) + medium_priority = len(doc.get_by_priority("medium")) + low_priority = len(doc.get_by_priority("low")) + + # Get user assignments + users = {} + for idea in doc.ideas: + if idea.assignee: + users[idea.assignee] = users.get(idea.assignee, 0) + 1 + + console.print("\n[bold]Ideas Collection Status[/bold]") + console.print(f"File: {ctx.obj['ideas_file']}") + console.print(f"Last modified: {doc.metadata.last_modified.strftime('%Y-%m-%d %H:%M')}") + console.print(f"By: {doc.metadata.last_modified_by}") + + console.print("\nšŸ“Š [bold]Statistics[/bold]") + console.print(f"Total ideas: {total_ideas}") + console.print(f"Assigned: {assigned}") + console.print(f"Unassigned: {unassigned}") + console.print(f"Active goals: {len(doc.get_active_goals())}") + + console.print("\nšŸŽÆ [bold]Priority Breakdown[/bold]") + console.print(f"High: {high_priority}") + console.print(f"Medium: {medium_priority}") + console.print(f"Low: {low_priority}") + + if users: + console.print("\nšŸ‘„ [bold]Assignments[/bold]") + for user, count in sorted(users.items()): + console.print(f"{user}: {count} ideas") + + +@ideas.command("init") +@click.option("--sample", is_flag=True, help="Create with sample data") +@click.pass_context +def init_file(ctx: click.Context, sample: bool) -> None: + """Initialize a new ideas file""" + + ideas_file: Path = ctx.obj["ideas_file"] + + if ideas_file.exists(): + console.print(f"āŒ Ideas file already exists: {ideas_file}") + console.print("Use --file to specify a different location") + sys.exit(1) + + storage: IdeasStorage = ctx.obj["storage"] + + if sample: + from amplifier.ideas.storage import create_sample_document + + doc = create_sample_document() + console.print("āœ… Created ideas file with sample data") + else: + doc = storage.load() # Creates empty document + console.print("āœ… Created empty ideas file") + + storage.save(doc) + console.print(f"šŸ“ Location: {ideas_file}") + + +@ideas.command() +@click.pass_context +def reorder(ctx: click.Context) -> None: + """Reorder ideas based on active goals using AI""" + + storage: IdeasStorage = ctx.obj["storage"] + doc = storage.load() + + active_goals = doc.get_active_goals() + if not active_goals: + console.print("āŒ No active goals found. Add goals first with 'add-goal'") + sys.exit(1) + + if not doc.ideas: + console.print("āŒ No ideas to reorder") + sys.exit(1) + + console.print(f"šŸŽÆ Reordering {len(doc.ideas)} ideas based on {len(active_goals)} goals...") + + # Import and run the operation + from amplifier.ideas.operations import reorder_ideas_by_goals + + async def run_reorder(): + return await reorder_ideas_by_goals(doc.ideas, active_goals) + + reordered_ideas = asyncio.run(run_reorder()) + + # Update the document with new order + doc.ideas = reordered_ideas + storage.save(doc, "ai-reorder") + + console.print("āœ… Ideas reordered based on goal alignment") + console.print("Use 'list' to see the new order") + + +@ideas.command() +@click.pass_context +def themes(ctx: click.Context) -> None: + """Detect common themes across ideas using AI""" + + storage: IdeasStorage = ctx.obj["storage"] + doc = storage.load() + + if not doc.ideas: + console.print("āŒ No ideas to analyze") + sys.exit(1) + + console.print(f"šŸ” Detecting themes in {len(doc.ideas)} ideas...") + + # Import and run the operation + + from amplifier.ideas.operations import detect_idea_themes + + async def run_detection(): + return await detect_idea_themes(doc.ideas) + + theme_groups = asyncio.run(run_detection()) + + if not theme_groups: + console.print("No common themes detected") + return + + # Display themes + table = Table(title="Detected Themes") + table.add_column("Theme", style="bold") + table.add_column("Description") + table.add_column("Ideas", style="dim") + + for theme in theme_groups: + idea_count = f"{len(theme.idea_ids)} ideas" + table.add_row(theme.name, theme.description, idea_count) + + console.print(table) + + +@ideas.command() +@click.argument("idea_id") +@click.pass_context +def similar(ctx: click.Context, idea_id: str) -> None: + """Find ideas similar to the specified idea using AI""" + + storage: IdeasStorage = ctx.obj["storage"] + doc = storage.load() + + target_idea = doc.find_idea(idea_id) + if not target_idea: + console.print(f"āŒ Idea not found: {idea_id}", err=True) + sys.exit(1) + + console.print(f"šŸ”Ž Finding ideas similar to: [bold]{target_idea.title}[/bold]") + + # Import and run the operation + from amplifier.ideas.operations import find_similar_to_idea + + async def run_similarity(): + return await find_similar_to_idea(target_idea, doc.ideas) + + similar_ideas = asyncio.run(run_similarity()) + + if not similar_ideas: + console.print("No similar ideas found") + return + + # Display similar ideas + table = Table(title=f"Ideas similar to: {target_idea.title}") + table.add_column("ID", style="dim") + table.add_column("Title", style="bold") + table.add_column("Themes", style="dim") + + for idea in similar_ideas: + themes_text = ", ".join(idea.themes) if idea.themes else "" + table.add_row(idea.id, idea.title, themes_text) + + console.print(table) + + +@ideas.command() +@click.pass_context +def optimize(ctx: click.Context) -> None: + """Optimize idea order for maximum leverage using AI""" + + storage: IdeasStorage = ctx.obj["storage"] + doc = storage.load() + + if not doc.ideas: + console.print("āŒ No ideas to optimize") + sys.exit(1) + + console.print(f"āš” Optimizing {len(doc.ideas)} ideas for maximum leverage...") + + # Import and run the operation + from amplifier.ideas.operations import optimize_ideas_for_leverage + + async def run_optimization(): + return await optimize_ideas_for_leverage(doc.ideas) + + optimized_ideas = asyncio.run(run_optimization()) + + # Update the document with new order + doc.ideas = optimized_ideas + storage.save(doc, "ai-optimize") + + console.print("āœ… Ideas optimized for leverage") + console.print("Use 'list' to see the optimized order") + + +if __name__ == "__main__": + ideas() diff --git a/amplifier/ideas/models.py b/amplifier/ideas/models.py new file mode 100644 index 00000000..413939af --- /dev/null +++ b/amplifier/ideas/models.py @@ -0,0 +1,168 @@ +""" +Pydantic models for the shared ideas management system. + +Defines the data structures for ideas, goals, and the overall document format. +Following the single YAML file storage approach with clean validation. +""" + +import uuid +from datetime import datetime +from typing import Literal + +from pydantic import BaseModel +from pydantic import Field + + +class Goal(BaseModel): + """Natural language goal for guiding idea prioritization""" + + id: str = Field(default_factory=lambda: f"goal_{uuid.uuid4().hex[:8]}") + description: str = Field(..., min_length=10, max_length=500) + priority: int = Field(default=1, ge=1) + created: datetime = Field(default_factory=datetime.now) + active: bool = True + + +class Idea(BaseModel): + """Individual idea with metadata and assignment information""" + + id: str = Field(default_factory=lambda: f"idea_{uuid.uuid4().hex[:8]}") + title: str = Field(..., min_length=3, max_length=200) + description: str = Field(default="", max_length=2000) + assignee: str | None = None # None means unassigned + rank: int | None = None # Position in assignee's queue + themes: list[str] = Field(default_factory=list) + priority: Literal["high", "medium", "low"] = "medium" + created: datetime = Field(default_factory=datetime.now) + modified: datetime = Field(default_factory=datetime.now) + notes: str | None = None + + def is_assigned(self) -> bool: + """Check if idea is assigned to someone""" + return self.assignee is not None + + def update_modified(self) -> None: + """Update the modified timestamp""" + self.modified = datetime.now() + + +class HistoryEntry(BaseModel): + """Audit trail entry for tracking changes""" + + timestamp: datetime = Field(default_factory=datetime.now) + action: Literal["create", "update", "assign", "unassign", "reorder", "delete"] + user: str = Field(default="system") + details: str + + +class Metadata(BaseModel): + """File metadata for tracking document state""" + + last_modified: datetime = Field(default_factory=datetime.now) + last_modified_by: str = Field(default="system") + total_ideas: int = Field(default=0, ge=0) + total_goals: int = Field(default=0, ge=0) + + +class IdeasDocument(BaseModel): + """Complete ideas document structure - the root data model""" + + version: str = Field(default="1.0", pattern=r"^\d+\.\d+$") + metadata: Metadata = Field(default_factory=Metadata) + goals: list[Goal] = Field(default_factory=list) + ideas: list[Idea] = Field(default_factory=list) + history: list[HistoryEntry] = Field(default_factory=list, max_length=1000) + + def get_user_queue(self, user: str) -> list[Idea]: + """Get ideas assigned to a specific user, sorted by rank""" + user_ideas = [i for i in self.ideas if i.assignee == user] + return sorted(user_ideas, key=lambda x: x.rank or float("inf")) + + def get_unassigned(self) -> list[Idea]: + """Get all unassigned ideas""" + return [i for i in self.ideas if i.assignee is None] + + def get_by_theme(self, theme: str) -> list[Idea]: + """Get ideas containing a specific theme""" + return [i for i in self.ideas if theme.lower() in [t.lower() for t in i.themes]] + + def get_by_priority(self, priority: Literal["high", "medium", "low"]) -> list[Idea]: + """Get ideas by priority level""" + return [i for i in self.ideas if i.priority == priority] + + def find_idea(self, idea_id: str) -> Idea | None: + """Find an idea by ID""" + return next((i for i in self.ideas if i.id == idea_id), None) + + def add_idea(self, idea: Idea, user: str = "system") -> None: + """Add a new idea and update metadata""" + self.ideas.append(idea) + self.metadata.total_ideas = len(self.ideas) + self.metadata.last_modified = datetime.now() + self.metadata.last_modified_by = user + + # Add history entry + self.history.append(HistoryEntry(action="create", user=user, details=f"Created idea: {idea.title}")) + + def remove_idea(self, idea_id: str, user: str = "system") -> bool: + """Remove an idea by ID""" + idea = self.find_idea(idea_id) + if not idea: + return False + + self.ideas = [i for i in self.ideas if i.id != idea_id] + self.metadata.total_ideas = len(self.ideas) + self.metadata.last_modified = datetime.now() + self.metadata.last_modified_by = user + + # Add history entry + self.history.append(HistoryEntry(action="delete", user=user, details=f"Deleted idea: {idea.title}")) + return True + + def assign_idea(self, idea_id: str, assignee: str, user: str = "system") -> bool: + """Assign an idea to a user""" + idea = self.find_idea(idea_id) + if not idea: + return False + + old_assignee = idea.assignee + idea.assignee = assignee + idea.update_modified() + + # Set rank to end of user's queue + user_queue = self.get_user_queue(assignee) + idea.rank = len(user_queue) + + self.metadata.last_modified = datetime.now() + self.metadata.last_modified_by = user + + # Add history entry + action = "assign" if old_assignee is None else "update" + details = f"Assigned idea '{idea.title}' to {assignee}" + if old_assignee: + details += f" (was: {old_assignee})" + + self.history.append(HistoryEntry(action=action, user=user, details=details)) + return True + + def add_goal(self, goal: Goal, user: str = "system") -> None: + """Add a new goal""" + self.goals.append(goal) + self.metadata.total_goals = len(self.goals) + self.metadata.last_modified = datetime.now() + self.metadata.last_modified_by = user + + # Add history entry + self.history.append(HistoryEntry(action="create", user=user, details=f"Added goal: {goal.description[:50]}...")) + + def get_active_goals(self) -> list[Goal]: + """Get all active goals, sorted by priority""" + active = [g for g in self.goals if g.active] + return sorted(active, key=lambda g: g.priority) + + def update_metadata(self, user: str = "system") -> None: + """Update document metadata""" + self.metadata.total_ideas = len(self.ideas) + self.metadata.total_goals = len(self.goals) + self.metadata.last_modified = datetime.now() + self.metadata.last_modified_by = user diff --git a/amplifier/ideas/operations.py b/amplifier/ideas/operations.py new file mode 100644 index 00000000..8c22b3b5 --- /dev/null +++ b/amplifier/ideas/operations.py @@ -0,0 +1,337 @@ +""" +LLM-powered operations for the ideas management system. + +Uses ccsdk_toolkit patterns for robust AI operations like goal-based reordering, +theme detection, and similarity analysis. Following the hybrid code/AI approach. +""" + +from typing import Any + +from pydantic import BaseModel + +from amplifier.ideas.models import Goal +from amplifier.ideas.models import Idea + + +class ReorderResult(BaseModel): + """Result from goal-based reordering operation""" + + reordered_ideas: list[dict[str, Any]] + analysis_summary: str + + +class ThemeGroup(BaseModel): + """A group of ideas sharing a common theme""" + + name: str + description: str + idea_ids: list[str] + + +class ThemeResult(BaseModel): + """Result from theme detection operation""" + + themes: list[ThemeGroup] + + +class SimilarityResult(BaseModel): + """Result from similarity analysis""" + + similar_ideas: list[dict[str, Any]] + explanation: str + + +class IdeasOperations: + """ + LLM-powered operations on ideas collections. + + This class provides the 'intelligence' part of the hybrid code/AI architecture. + Code handles the structure (data management, chunking) while AI provides + the intelligence (understanding goals, finding patterns). + """ + + def __init__(self): + """Initialize operations handler""" + # In a full implementation, this would initialize Claude SDK connection + # For now, we'll provide mock implementations that show the structure + self.chunk_size = 15 # Process ideas in chunks for better LLM performance + + async def reorder_by_goals(self, ideas: list[Idea], goals: list[Goal]) -> list[Idea]: + """ + Reorder ideas based on goal alignment. + + Uses LLM to analyze how well each idea aligns with the active goals + and reorders them accordingly. + """ + if not ideas or not goals: + return ideas + + # For now, provide a simple mock implementation + # In full implementation, this would use ccsdk_toolkit + print(f"šŸŽÆ Reordering {len(ideas)} ideas based on {len(goals)} goals...") + + # Simple mock: prioritize ideas that contain goal-related keywords + goal_keywords = self._extract_goal_keywords(goals) + + def alignment_score(idea: Idea) -> float: + """Score how well an idea aligns with goals""" + score = 0.0 + text = f"{idea.title} {idea.description}".lower() + + for keyword in goal_keywords: + if keyword.lower() in text: + score += 1.0 + + # Boost high priority items + if idea.priority == "high": + score += 0.5 + elif idea.priority == "low": + score -= 0.3 + + return score + + # Sort by alignment score (descending) + reordered = sorted(ideas, key=alignment_score, reverse=True) + + print("āœ… Reordered ideas based on goal alignment") + return reordered + + async def detect_themes(self, ideas: list[Idea]) -> list[ThemeGroup]: + """ + Detect common themes across ideas using LLM analysis. + + Groups ideas by discovered themes and provides descriptions. + """ + if not ideas: + return [] + + print(f"šŸ” Detecting themes in {len(ideas)} ideas...") + + # Mock implementation - in real version would use LLM + theme_groups = [] + + # Group by existing themes first + existing_themes = {} + for idea in ideas: + for theme in idea.themes: + if theme not in existing_themes: + existing_themes[theme] = [] + existing_themes[theme].append(idea.id) + + # Convert to theme groups + for theme_name, idea_ids in existing_themes.items(): + if len(idea_ids) > 1: # Only themes with multiple ideas + theme_groups.append( + ThemeGroup(name=theme_name, description=f"Ideas related to {theme_name}", idea_ids=idea_ids) + ) + + # Add discovered themes (mock) + ui_ideas = [ + i.id + for i in ideas + if any( + word in f"{i.title} {i.description}".lower() + for word in ["ui", "interface", "user", "design", "experience"] + ) + ] + + if len(ui_ideas) > 1: + theme_groups.append( + ThemeGroup( + name="user_interface", + description="Ideas focused on user interface and experience improvements", + idea_ids=ui_ideas, + ) + ) + + performance_ideas = [ + i.id + for i in ideas + if any( + word in f"{i.title} {i.description}".lower() + for word in ["performance", "speed", "optimize", "cache", "fast"] + ) + ] + + if len(performance_ideas) > 1: + theme_groups.append( + ThemeGroup( + name="performance", + description="Ideas aimed at improving system performance and speed", + idea_ids=performance_ideas, + ) + ) + + print(f"āœ… Detected {len(theme_groups)} themes") + return theme_groups + + async def find_similar_ideas(self, target_idea: Idea, all_ideas: list[Idea]) -> list[Idea]: + """ + Find ideas similar to the target idea using semantic analysis. + """ + if not all_ideas: + return [] + + print(f"šŸ”Ž Finding ideas similar to: {target_idea.title}") + + # Mock implementation - would use LLM for semantic similarity + similar = [] + target_text = f"{target_idea.title} {target_idea.description}".lower() + target_themes = set(target_idea.themes) + + for idea in all_ideas: + if idea.id == target_idea.id: + continue + + similarity_score = 0.0 + idea_text = f"{idea.title} {idea.description}".lower() + idea_themes = set(idea.themes) + + # Theme overlap + theme_overlap = len(target_themes & idea_themes) + if theme_overlap > 0: + similarity_score += theme_overlap * 2.0 + + # Simple text similarity (word overlap) + target_words = set(target_text.split()) + idea_words = set(idea_text.split()) + word_overlap = len(target_words & idea_words) + + if word_overlap > 2: # Ignore common words + similarity_score += word_overlap * 0.5 + + # Priority similarity + if idea.priority == target_idea.priority: + similarity_score += 0.5 + + if similarity_score > 1.0: # Threshold for similarity + similar.append((idea, similarity_score)) + + # Sort by similarity score and return top matches + similar.sort(key=lambda x: x[1], reverse=True) + result = [idea for idea, score in similar[:5]] # Top 5 similar + + print(f"āœ… Found {len(result)} similar ideas") + return result + + async def suggest_assignments(self, ideas: list[Idea], team_context: str = "") -> dict[str, list[Idea]]: + """ + Suggest idea assignments based on team member skills and current workload. + """ + if not ideas: + return {} + + unassigned = [i for i in ideas if not i.is_assigned()] + if not unassigned: + return {} + + print(f"šŸ‘„ Suggesting assignments for {len(unassigned)} unassigned ideas...") + + # Mock assignment logic - would use LLM for intelligent matching + suggestions = {} + + for idea in unassigned: + # Simple heuristic assignment based on themes + suggested_user = None + + if any(theme in ["ui", "ux", "design"] for theme in idea.themes): + suggested_user = "ui_specialist" + elif any(theme in ["performance", "infrastructure", "backend"] for theme in idea.themes): + suggested_user = "backend_engineer" + elif any(theme in ["documentation", "api"] for theme in idea.themes): + suggested_user = "tech_writer" + else: + suggested_user = "general_developer" + + if suggested_user not in suggestions: + suggestions[suggested_user] = [] + suggestions[suggested_user].append(idea) + + print(f"āœ… Generated assignment suggestions for {len(suggestions)} roles") + return suggestions + + async def optimize_for_leverage(self, ideas: list[Idea]) -> list[Idea]: + """ + Reorder ideas to prioritize high-leverage items that unlock other work. + """ + print(f"āš” Optimizing {len(ideas)} ideas for maximum leverage...") + + # Mock leverage analysis - would use LLM for dependency understanding + def leverage_score(idea: Idea) -> float: + """Score idea based on potential leverage/impact""" + score = 0.0 + text = f"{idea.title} {idea.description}".lower() + + # Infrastructure/foundation work has high leverage + if any(word in text for word in ["infrastructure", "framework", "api", "architecture", "foundation"]): + score += 3.0 + + # Documentation enables others + if any(word in text for word in ["documentation", "docs", "guide", "tutorial"]): + score += 2.0 + + # Tools and automation multiply effort + if any(word in text for word in ["tool", "automation", "script", "pipeline"]): + score += 2.5 + + # Security and performance affect everything + if any(word in text for word in ["security", "performance", "optimization"]): + score += 1.5 + + # High priority items get a boost + if idea.priority == "high": + score += 1.0 + + return score + + # Sort by leverage score + optimized = sorted(ideas, key=leverage_score, reverse=True) + + print("āœ… Optimized ideas for leverage") + return optimized + + def _extract_goal_keywords(self, goals: list[Goal]) -> list[str]: + """Extract key terms from goals for matching""" + keywords = [] + for goal in goals: + # Simple keyword extraction - would use LLM for better analysis + words = goal.description.lower().split() + # Filter out common words + important_words = [ + w + for w in words + if len(w) > 3 and w not in {"and", "the", "for", "with", "that", "this", "from", "they", "have", "will"} + ] + keywords.extend(important_words) + return list(set(keywords)) + + +# Convenience functions for CLI integration +async def reorder_ideas_by_goals(ideas: list[Idea], goals: list[Goal]) -> list[Idea]: + """Convenience function for goal-based reordering""" + ops = IdeasOperations() + return await ops.reorder_by_goals(ideas, goals) + + +async def detect_idea_themes(ideas: list[Idea]) -> list[ThemeGroup]: + """Convenience function for theme detection""" + ops = IdeasOperations() + return await ops.detect_themes(ideas) + + +async def find_similar_to_idea(target_idea: Idea, all_ideas: list[Idea]) -> list[Idea]: + """Convenience function for similarity search""" + ops = IdeasOperations() + return await ops.find_similar_ideas(target_idea, all_ideas) + + +async def suggest_idea_assignments(ideas: list[Idea], team_context: str = "") -> dict[str, list[Idea]]: + """Convenience function for assignment suggestions""" + ops = IdeasOperations() + return await ops.suggest_assignments(ideas, team_context) + + +async def optimize_ideas_for_leverage(ideas: list[Idea]) -> list[Idea]: + """Convenience function for leverage optimization""" + ops = IdeasOperations() + return await ops.optimize_for_leverage(ideas) diff --git a/amplifier/ideas/storage.py b/amplifier/ideas/storage.py new file mode 100644 index 00000000..9504cbb6 --- /dev/null +++ b/amplifier/ideas/storage.py @@ -0,0 +1,237 @@ +""" +YAML storage layer with defensive file I/O patterns. + +Handles atomic saves, backup creation, and retry logic for cloud sync issues. +Following the single source of truth pattern with robust error handling. +""" + +import shutil +import time +from pathlib import Path + +import yaml +from filelock import FileLock + +from amplifier.ideas.models import IdeasDocument + + +class IdeasStorage: + """ + Storage layer for ideas documents with defensive patterns. + + Handles the "brick" of data persistence with atomic operations, + cloud sync resilience, and backup management. + """ + + def __init__(self, filepath: str | Path): + self.filepath = Path(filepath) + self.lockfile = Path(f"{filepath}.lock") + self.backup_dir = self.filepath.parent / "backups" + + # Ensure directories exist + self.filepath.parent.mkdir(parents=True, exist_ok=True) + self.backup_dir.mkdir(exist_ok=True) + + def load(self) -> IdeasDocument: + """ + Load ideas document from YAML file with retry logic. + + Returns empty document if file doesn't exist. + Retries on cloud sync delays (OneDrive, Dropbox, etc.) + """ + if not self.filepath.exists(): + return IdeasDocument() + + max_retries = 3 + retry_delay = 1.0 + + for attempt in range(max_retries): + try: + with open(self.filepath, encoding="utf-8") as f: + data = yaml.safe_load(f) + + if data is None: # Empty file + return IdeasDocument() + + return IdeasDocument(**data) + + except OSError as e: + if e.errno == 5 and attempt < max_retries - 1: # I/O error, likely cloud sync + if attempt == 0: + print(f"āš ļø File I/O delay loading {self.filepath} - retrying...") + print(" This may be due to cloud sync (OneDrive, Dropbox, etc.)") + time.sleep(retry_delay) + retry_delay *= 2 + continue + raise + except yaml.YAMLError as e: + raise ValueError(f"Invalid YAML in {self.filepath}: {e}") + except Exception as e: + raise RuntimeError(f"Failed to load ideas from {self.filepath}: {e}") + + raise RuntimeError(f"Failed to load after {max_retries} attempts") + + def save(self, doc: IdeasDocument, user: str = "system") -> None: + """ + Atomic save with backup and retry logic. + + Creates backup of existing file before writing. + Uses temp file + rename for atomicity. + Retries on cloud sync issues. + """ + # Update metadata + doc.update_metadata(user) + + max_retries = 3 + retry_delay = 1.0 + + with FileLock(self.lockfile, timeout=10): + # Create backup of existing file + if self.filepath.exists(): + backup_path = self._create_backup() + if backup_path: + print(f"šŸ’¾ Backed up to {backup_path.name}") + + # Atomic write with retry + temp_file = self.filepath.with_suffix(".tmp") + + for attempt in range(max_retries): + try: + # Convert to dict and write to temp file + data = doc.model_dump(mode="json") + + with open(temp_file, "w", encoding="utf-8") as f: + yaml.dump(data, f, default_flow_style=False, sort_keys=False, allow_unicode=True, indent=2) + f.flush() + + # Atomic rename + temp_file.replace(self.filepath) + return + + except OSError as e: + if e.errno == 5 and attempt < max_retries - 1: # I/O error + if attempt == 0: + print(f"āš ļø File I/O delay saving {self.filepath} - retrying...") + print(" This may be due to cloud sync (OneDrive, Dropbox, etc.)") + time.sleep(retry_delay) + retry_delay *= 2 + continue + # Clean up temp file on error + if temp_file.exists(): + temp_file.unlink() + raise + except Exception as e: + # Clean up temp file on error + if temp_file.exists(): + temp_file.unlink() + raise RuntimeError(f"Failed to save ideas to {self.filepath}: {e}") + + raise RuntimeError(f"Failed to save after {max_retries} attempts") + + def backup(self) -> Path | None: + """Create a timestamped backup of the current file""" + return self._create_backup() + + def _create_backup(self) -> Path | None: + """Create backup with timestamp""" + if not self.filepath.exists(): + return None + + timestamp = time.strftime("%Y%m%d_%H%M%S") + backup_path = self.backup_dir / f"{self.filepath.stem}_{timestamp}.yaml" + + try: + shutil.copy2(self.filepath, backup_path) + # Keep only last 10 backups + self._cleanup_old_backups() + return backup_path + except Exception as e: + print(f"āš ļø Warning: Failed to create backup: {e}") + return None + + def _cleanup_old_backups(self, keep: int = 10) -> None: + """Remove old backup files, keeping only the most recent""" + try: + backups = list(self.backup_dir.glob(f"{self.filepath.stem}_*.yaml")) + if len(backups) > keep: + # Sort by modification time, remove oldest + backups.sort(key=lambda p: p.stat().st_mtime) + for old_backup in backups[:-keep]: + old_backup.unlink() + except Exception: + pass # Backup cleanup is not critical + + def exists(self) -> bool: + """Check if the ideas file exists""" + return self.filepath.exists() + + def get_filepath(self) -> Path: + """Get the full file path""" + return self.filepath + + def get_backup_dir(self) -> Path: + """Get the backup directory path""" + return self.backup_dir + + +def get_default_ideas_file() -> Path: + """ + Get the default ideas file path. + + Uses environment variable AMPLIFIER_IDEAS_FILE if set, + otherwise defaults to ~/amplifier/ideas.yaml + """ + import os + + # Check environment variable first + env_path = os.getenv("AMPLIFIER_IDEAS_FILE") + if env_path: + return Path(env_path).expanduser() + + # Default to home directory + return Path.home() / "amplifier" / "ideas.yaml" + + +def create_sample_document() -> IdeasDocument: + """Create a sample ideas document for testing""" + from amplifier.ideas.models import Goal + from amplifier.ideas.models import Idea + + doc = IdeasDocument() + + # Add sample goals + doc.add_goal(Goal(description="Focus on improving user experience and onboarding", priority=1)) + + doc.add_goal(Goal(description="Reduce technical debt and improve system reliability", priority=2)) + + # Add sample ideas + idea1 = Idea( + title="Add dark mode toggle", + description="Implement theme switching with user preference persistence", + themes=["ui", "ux"], + priority="high", + ) + doc.add_idea(idea1) + + idea2 = Idea( + title="Implement caching layer", + description="Add Redis caching for frequently accessed data to improve performance", + themes=["performance", "infrastructure"], + priority="medium", + ) + doc.add_idea(idea2) + + idea3 = Idea( + title="Create user onboarding tutorial", + description="Step-by-step walkthrough for new users", + themes=["onboarding", "ux"], + priority="high", + ) + doc.add_idea(idea3) + + # Assign some ideas + doc.assign_idea(idea1.id, "alice") + doc.assign_idea(idea2.id, "bob") + # idea3 remains unassigned + + return doc