@robbiesrobotics/alice-agents 1.5.8 → 1.5.9

package/templates/workspaces/olivia/skills/cloud-storage/costs.md

@@ -0,0 +1,88 @@
+# Cost Calculation
+
+## The Three Cost Categories
+
+| Category | What it includes | Often overlooked |
+|----------|-----------------|------------------|
+| Storage | GB/month stored | Minimum storage duration (Glacier = 90 days) |
+| Operations | PUT, GET, LIST requests | LIST is expensive at scale |
+| Transfer | Egress bandwidth | Usually the biggest surprise |
+
+---
+
+## Cost Comparison (approximate, verify current pricing)
+
+| Provider | Storage/GB/mo | Egress/GB | PUT/10K | GET/10K |
+|----------|--------------|-----------|---------|---------|
+| S3 Standard | $0.023 | $0.09 | $0.05 | $0.004 |
+| S3 Glacier | $0.004 | $0.09 + retrieval | $0.05 | varies |
+| GCS Standard | $0.020 | $0.12 | $0.05 | $0.004 |
+| Azure Hot | $0.018 | $0.087 | $0.05 | $0.004 |
+| Backblaze B2 | $0.006 | $0.01 | free | free |
+| Cloudflare R2 | $0.015 | **FREE** | $4.50/M | $0.36/M |
+
+**Key insight:** R2 wins for serving public content; B2 wins for archival.
+
+---
+
+## Hidden Costs
+
+### Minimum Storage Duration
+- **S3 Glacier:** 90 days minimum; delete early = charged for 90 days anyway
+- **S3 Deep Archive:** 180 days minimum
+- **GCS Archive:** 365 days minimum
+
+### Small File Overhead
+- **B2:** Files <10KB charged as 10KB
+- **Glacier:** Per-request overhead makes small files expensive
+
+### API Call Costs at Scale
+- **LIST operations:** $5/million objects listed
+- **10M files to audit:** ~$50 just to list them
+- **Use inventories** for large buckets (S3 Inventory = $0.0025/M objects)
+
+### Cross-Region Egress
+- Replicating between regions = egress fees both ways
+- Same-region replication = no egress but still PUT costs
+
+---
+
+## Before Large Operations
+
+### Migration Cost Estimate
+
+```
+Files: 100,000
+Size: 500 GB
+Source: S3 us-east-1
+Destination: GCS europe-west1
+
+Egress from S3: 500 GB × $0.09 = $45
+PUT to GCS: 100,000 ÷ 10,000 × $0.05 = $0.50
+Total: ~$46
+
+Compare: Just keep in S3 = $0.023 × 500 = $11.50/month
+Break-even: ~4 months
+```
+
+### Serving Cost Estimate
+
+```
+Monthly serves: 10M requests
+Average file: 1 MB
+
+Egress: 10 TB × $0.09 = $900 (S3)
+Egress: 10 TB × $0.00 = $0 (R2)
+
+R2 saves $900/month for high-traffic serving
+```
+
+---
+
+## Cost Optimization Checklist
+
+- [ ] Are cold files in cold storage tier?
+- [ ] Are lifecycle rules moving/deleting unused files?
+- [ ] Is egress the main cost? Consider CDN or R2
+- [ ] Are you listing the same objects repeatedly? Cache or use inventories
+- [ ] Multi-part uploads abandoned? Enable cleanup rules

package/templates/workspaces/olivia/skills/cloud-storage/providers.md

@@ -0,0 +1,55 @@
+# Provider-Specific Patterns
+
+## Object Storage (S3-compatible)
+
+### AWS S3
+- **Presigned URLs** — v4 signatures required; include `Content-Type` for uploads
+- **Eventual consistency** — `PUT` then immediate `GET` may 404; wait or use strong consistency regions
+- **Lifecycle rules** — transition conflicts with delete; check rule order
+
+### Google Cloud Storage
+- **Signed URLs** — use `signBlob` IAM permission; service account required
+- **Object holds** — legal hold blocks deletion even by owner
+- **Composite objects** — max 32 components per compose operation
+
+### Azure Blob
+- **SAS tokens** — account-level vs container-level vs blob-level scope
+- **Hot/Cool/Archive** — archive retrieval takes hours; plan ahead
+- **Soft delete** — enabled by default on new accounts; check retention
+
+### Backblaze B2
+- **S3-compatible API** — most S3 tools work; use `s3.region.backblazeb2.com` endpoint
+- **Application keys** — bucket-restricted keys for least privilege
+- **Minimum file size** — small files charged as 10KB minimum
+
+### Cloudflare R2
+- **No egress fees** — major cost advantage for serving content
+- **S3 compatibility** — most operations work; some advanced features missing
+- **Workers integration** — can access R2 without egress via Workers
+
+---
+
+## Consumer/Prosumer Storage
+
+### Google Drive
+- **Shortcuts vs files** — shortcuts don't copy; operations on shortcuts affect original
+- **Shared drives** — different ownership model; files owned by organization
+- **API quotas** — 10 queries/second/user; batch requests help
+- **Export formats** — Google Docs download as DOCX/PDF, not native format
+
+### Dropbox
+- **Team folders** — admin controls override user permissions
+- **Paper docs** — separate from regular files; different API
+- **Selective sync** — `.dropbox` files appear when excluded
+- **2GB file limit** — API upload; desktop client handles larger via chunked
+
+### OneDrive / SharePoint
+- **Personal vs Business** — different APIs, quotas, features
+- **Conflict handling** — renames to `file (1).txt` automatically
+- **SharePoint libraries** — complex permission inheritance
+- **Delta sync** — use delta API for efficient change detection
+
+### iCloud
+- **No public API** — use CloudKit for app data, not file access
+- **Optimized storage** — files may be stubs; download before operations
+- **Family sharing** — shared folder permissions are limited

package/templates/workspaces/olivia/skills/copywriting-pro/SKILL.md

@@ -0,0 +1,107 @@
+---
+name: copywriting
+description: Write persuasive, high-converting copy for any format — ads, landing pages, emails, sales pages, headlines, product descriptions, CTAs, and social posts. Applies professional copywriting SOPs including avatar/ICP development, Voice of Customer research, Eugene Schwartz's 5 Stages of Awareness, AIDA, PAS, BAB, FAB frameworks, the TIMER offer framework, readability rules (Grade 6, ≤14 words/sentence), psychological triggers (scarcity, social proof, loss aversion, reciprocity), and the 4 C's quality checklist. Use when a user asks to write, improve, rewrite, or review any marketing or sales copy.
+---
+
+# Copywriting Skill
+
+Produces high-converting copy using proven professional SOPs. Follow this skill in order — research before writing, framework before words, checklist before publishing.
+
+## Core Principle
+
+> Great copy is never written. It's discovered. Your job is to find the words your buyer already uses — then play them back.
+
+## Workflow
+
+### Step 1 — Research & Avatar (before writing anything)
+
+Ask or determine:
+- Who is the ONE specific person this is written for? (Not a demographic range — one person with a name)
+- What is their awareness stage? (See `references/awareness-and-frameworks.md`)
+- What exact words do they use to describe their problem?
+
+**If VoC data is available** (reviews, testimonials, interviews, support tickets): mine it for exact phrases. Use their words, not yours.
+
+**Avatar must-knows:**
+- What keeps them up at 3am?
+- What have they already tried that failed?
+- What's their dream outcome?
+- What objection will they raise before buying?
+
+### Step 2 — Pick the Right Framework
+
+| Writing... | Use |
+|---|---|
+| Cold ad / social post | PAS or Awareness Stage 1–2 hook |
+| Landing page / sales page | AIDA (full) |
+| Email subject line | Curiosity gap or number headline formula |
+| Product bullets | FAB (Features → Advantages → Benefits) |
+| Testimonial / case study | BAB (Before → After → Bridge) |
+| Offer description | TIMER lever mapping |
+| Any copy quality review | 4 C's checklist |
+
+Full framework details + examples: `references/awareness-and-frameworks.md`
+
+### Step 3 — Write the Headline First
+
+Spend 50% of your effort here. 80% of readers read only the headline.
+
+Every strong headline has ≥2 of the **4 U's**: Useful, Urgent, Unique, Ultra-specific.
+
+Top formulas:
+- `How to [Outcome] Without [Fear/Objection]`
+- `[Number] [Things] [ICP] Should Know About [Topic]`
+- `[Common Belief] — But Here's What They Don't Tell You`
+- `[Outcome] in [Timeframe] — Or [Guarantee]`
+- `If You [Problem], Then [Solution]`
+- `Are You [Experiencing Painful Problem]?`
+
+### Step 4 — Write the Body
+
+Apply framework structure. Layer in psychological triggers throughout:
+
+| Trigger | How |
+|---|---|
+| Social proof | Exact numbers: "487 five-star reviews" |
+| Scarcity | Real limits: "3 spots left in April" |
+| Urgency | Real deadline: "Offer ends Friday" |
+| Loss aversion | Frame as loss avoided: "Stop losing $X/month" |
+| Risk reversal | Guarantee: removes fear of being wrong |
+| Reciprocity | Give value first — people feel compelled to return it |
+| Authority | Credentials, awards, years, certifications |
+| Specificity | Exact numbers = credibility; round numbers = skepticism |
+
+### Step 5 — Language Rules (Non-Negotiable)
+
+- **Grade 6 reading level** — Flesch-Kincaid 5–7. Use Hemingway Editor.
+- **≤14 words per sentence** — comprehension drops sharply above this
+- **Small words win** — "use" not "utilize," "show" not "demonstrate," "buy" not "purchase"
+- **Specificity wins** — "cut your bill by $80/month" not "save money"
+- **Empathy first** — enter their world before talking about you
+- **Their language** — use the exact phrases from VoC research, not industry jargon
+- **Read it out loud** — if it sounds like a brochure, rewrite it
+
+Full language rules + small-word swap table: `references/language-and-readability.md`
+
+### Step 6 — Write the CTA
+
+One ask. Always one.
+
+Formula: `[Action Verb] + [Specific Outcome] + [Time/Ease Qualifier]`
+
+Examples:
+- "Book Your Free Lawn Audit — Takes 2 Minutes"
+- "Get My Custom Plan Today — No Obligation"
+- "Claim Your Spot Before Friday"
+
+### Step 7 — Run the Pre-Flight Checklist
+
+Before any copy goes live, verify:
+
+**Strategy:** One avatar? Awareness stage matched? Enters their conversation?
+**Structure:** Framework applied? Offer maps to TIMER? Headline has 2+ U's?
+**Language:** Grade 6? Short sentences? Small words? Sounds human? Uses their language?
+**Persuasion:** Specifics? Social proof? Risk reversal? Real urgency?
+**CTA:** One ask? Verb-led? Names the outcome?
+
+Full checklist with all items: `references/preflight-checklist.md`

package/templates/workspaces/olivia/skills/copywriting-pro/_meta.json

@@ -0,0 +1,6 @@
+{
+  "ownerId": "kn74jzwbvn1aznp8sg5tcbg1dd8085bd",
+  "slug": "copywriting-pro",
+  "version": "1.0.0",
+  "publishedAt": 1772501246523
+}

package/templates/workspaces/olivia/skills/data-analyst-pro/SKILL.md

@@ -0,0 +1,21 @@
+---
+name: data-analyst
+description: Complete the data analysis tasks delegated by the user.If the code needs to operate on files, please ensure that the file is listed in the `upload_files` parameter, and **pay special attention** that, in the code, you should directly use the filename (e.g., `open('data.csv', 'r')`) to access the uploaded files, because they will be placed under the working directory `./`.
+---
+
+# Data Analyst
+
+## Overview
+
+This skill provides specialized capabilities for data analyst.
+
+## Instructions
+
+Complete the data analysis tasks delegated by the user.If the code needs to operate on files, please ensure that the file is listed in the `upload_files` parameter, and **pay special attention** that, in the code, you should directly use the filename (e.g., `open('data.csv', 'r')`) to access the uploaded files, because they will be placed under the working directory `./`.
+
+
+## Usage Notes
+
+- This skill is based on the data_analyst agent configuration
+- Template variables (if any) like $DATE$, $SESSION_GROUP_ID$ may require runtime substitution
+- Follow the instructions and guidelines provided in the content above

package/templates/workspaces/olivia/skills/data-analyst-pro/_meta.json

@@ -0,0 +1,6 @@
+{
+  "ownerId": "kn71xkrq2fawjvteej73gsx71s80p3kb",
+  "slug": "data-analyst-pro",
+  "version": "0.1.0",
+  "publishedAt": 1771141367019
+}

package/templates/workspaces/olivia/skills/database-designer/README.md

@@ -0,0 +1,388 @@
+# Database Designer - POWERFUL Tier Skill
+
+A comprehensive database design and analysis toolkit that provides expert-level schema analysis, index optimization, and migration generation capabilities for modern database systems.
+
+## Features
+
+### 🔍 Schema Analyzer
+- **Normalization Analysis**: Automated detection of 1NF through BCNF violations
+- **Data Type Optimization**: Identifies antipatterns and inappropriate types
+- **Constraint Analysis**: Finds missing foreign keys, unique constraints, and checks
+- **ERD Generation**: Creates Mermaid diagrams from DDL or JSON schema
+- **Naming Convention Validation**: Ensures consistent naming patterns
+
+### ⚡ Index Optimizer  
+- **Missing Index Detection**: Identifies indexes needed for query patterns
+- **Composite Index Design**: Optimizes column ordering for maximum efficiency
+- **Redundancy Analysis**: Finds duplicate and overlapping indexes
+- **Performance Modeling**: Estimates selectivity and query performance impact
+- **Covering Index Recommendations**: Eliminates table lookups
+
+### 🚀 Migration Generator
+- **Zero-Downtime Migrations**: Implements expand-contract patterns
+- **Schema Evolution**: Handles column changes, table renames, constraint updates
+- **Data Migration Scripts**: Automated data transformation and validation
+- **Rollback Planning**: Complete reversal capabilities for all changes
+- **Execution Orchestration**: Dependency-aware migration ordering
+
+## Quick Start
+
+### Prerequisites
+- Python 3.7+ (no external dependencies required)
+- Database schema in SQL DDL format or JSON
+- Query patterns (for index optimization)
+
+### Installation
+```bash
+# Clone or download the database-designer skill
+cd engineering/database-designer/
+
+# Make scripts executable
+chmod +x *.py
+```
+
+## Usage Examples
+
+### Schema Analysis
+
+**Analyze SQL DDL file:**
+```bash
+python schema_analyzer.py --input assets/sample_schema.sql --output-format text
+```
+
+**Generate ERD diagram:**
+```bash
+python schema_analyzer.py --input assets/sample_schema.sql --generate-erd --output analysis.txt
+```
+
+**JSON schema analysis:**
+```bash
+python schema_analyzer.py --input assets/sample_schema.json --output-format json --output results.json
+```
+
+### Index Optimization
+
+**Basic index analysis:**
+```bash
+python index_optimizer.py --schema assets/sample_schema.json --queries assets/sample_query_patterns.json
+```
+
+**High-priority recommendations only:**
+```bash
+python index_optimizer.py --schema assets/sample_schema.json --queries assets/sample_query_patterns.json --min-priority 2
+```
+
+**JSON output with existing index analysis:**
+```bash
+python index_optimizer.py --schema assets/sample_schema.json --queries assets/sample_query_patterns.json --format json --analyze-existing
+```
+
+### Migration Generation
+
+**Generate migration between schemas:**
+```bash
+python migration_generator.py --current assets/current_schema.json --target assets/target_schema.json
+```
+
+**Zero-downtime migration:**
+```bash
+python migration_generator.py --current current.json --target target.json --zero-downtime --format sql
+```
+
+**Include validation queries:**
+```bash
+python migration_generator.py --current current.json --target target.json --include-validations --output migration_plan.txt
+```
+
+## Tool Documentation
+
+### Schema Analyzer
+
+**Input Formats:**
+- SQL DDL files (.sql)
+- JSON schema definitions (.json)
+
+**Key Capabilities:**
+- Detects 1NF violations (non-atomic values, repeating groups)
+- Identifies 2NF issues (partial dependencies in composite keys)
+- Finds 3NF problems (transitive dependencies)
+- Checks BCNF compliance (determinant key requirements)
+- Validates data types (VARCHAR(255) antipattern, inappropriate types)
+- Missing constraints (NOT NULL, UNIQUE, CHECK, foreign keys)
+- Naming convention adherence
+
+**Sample Command:**
+```bash
+python schema_analyzer.py \
+  --input sample_schema.sql \
+  --generate-erd \
+  --output-format text \
+  --output analysis.txt
+```
+
+**Output:**
+- Comprehensive text or JSON analysis report
+- Mermaid ERD diagram
+- Prioritized recommendations
+- SQL statements for improvements
+
+### Index Optimizer
+
+**Input Requirements:**
+- Schema definition (JSON format)
+- Query patterns with frequency and selectivity data
+
+**Analysis Features:**
+- Selectivity estimation based on column patterns
+- Composite index column ordering optimization  
+- Covering index recommendations for SELECT queries
+- Foreign key index validation
+- Redundancy detection (duplicates, overlaps, unused indexes)
+- Performance impact modeling
+
+**Sample Command:**
+```bash
+python index_optimizer.py \
+  --schema schema.json \
+  --queries query_patterns.json \
+  --format text \
+  --min-priority 3 \
+  --output recommendations.txt
+```
+
+**Output:**
+- Prioritized index recommendations
+- CREATE INDEX statements
+- Drop statements for redundant indexes
+- Performance impact analysis
+- Storage size estimates
+
+### Migration Generator
+
+**Input Requirements:**
+- Current schema (JSON format)
+- Target schema (JSON format)
+
+**Migration Strategies:**
+- Standard migrations with ALTER statements
+- Zero-downtime expand-contract patterns
+- Data migration and transformation scripts
+- Constraint management (add/drop in correct order)
+- Index management with timing estimates
+
+**Sample Command:**
+```bash
+python migration_generator.py \
+  --current current_schema.json \
+  --target target_schema.json \
+  --zero-downtime \
+  --include-validations \
+  --format text
+```
+
+**Output:**
+- Step-by-step migration plan
+- Forward and rollback SQL statements
+- Risk assessment for each step
+- Validation queries
+- Execution time estimates
+
+## File Structure
+
+```
+database-designer/
+├── README.md                          # This file
+├── SKILL.md                          # Comprehensive database design guide
+├── schema_analyzer.py                # Schema analysis tool
+├── index_optimizer.py                # Index optimization tool  
+├── migration_generator.py            # Migration generation tool
+├── references/                       # Reference documentation
+│   ├── normalization_guide.md        # Normalization principles and patterns
+│   ├── index_strategy_patterns.md    # Index design and optimization guide
+│   └── database_selection_decision_tree.md # Database technology selection
+├── assets/                           # Sample files and test data
+│   ├── sample_schema.sql            # Sample DDL with various issues
+│   ├── sample_schema.json           # JSON schema definition
+│   └── sample_query_patterns.json   # Query patterns for index analysis
+└── expected_outputs/                 # Example tool outputs
+    ├── schema_analysis_sample.txt   # Sample schema analysis report
+    ├── index_optimization_sample.txt # Sample index recommendations
+    └── migration_sample.txt         # Sample migration plan
+```
+
+## JSON Schema Format
+
+The tools use a standardized JSON format for schema definitions:
+
+```json
+{
+  "tables": {
+    "table_name": {
+      "columns": {
+        "column_name": {
+          "type": "VARCHAR(255)",
+          "nullable": true,
+          "unique": false,
+          "foreign_key": "other_table.column",
+          "default": "default_value",
+          "cardinality_estimate": 1000
+        }
+      },
+      "primary_key": ["id"],
+      "unique_constraints": [["email"], ["username"]],
+      "check_constraints": {
+        "chk_positive_price": "price > 0"
+      },
+      "indexes": [
+        {
+          "name": "idx_table_column",
+          "columns": ["column_name"],
+          "unique": false,
+          "partial_condition": "status = 'active'"
+        }
+      ]
+    }
+  }
+}
+```
+
+## Query Patterns Format
+
+For index optimization, provide query patterns in this format:
+
+```json
+{
+  "queries": [
+    {
+      "id": "user_lookup",
+      "type": "SELECT",
+      "table": "users",
+      "where_conditions": [
+        {
+          "column": "email",
+          "operator": "=",
+          "selectivity": 0.95
+        }
+      ],
+      "join_conditions": [
+        {
+          "local_column": "user_id",
+          "foreign_table": "orders",
+          "foreign_column": "id",
+          "join_type": "INNER"
+        }
+      ],
+      "order_by": [
+        {"column": "created_at", "direction": "DESC"}
+      ],
+      "frequency": 1000,
+      "avg_execution_time_ms": 5.2
+    }
+  ]
+}
+```
+
+## Best Practices
+
+### Schema Analysis
+1. **Start with DDL**: Use actual CREATE TABLE statements when possible
+2. **Include Constraints**: Capture all existing constraints and indexes
+3. **Consider History**: Some denormalization may be intentional for performance
+4. **Validate Results**: Review recommendations against business requirements
+
+### Index Optimization  
+1. **Real Query Patterns**: Use actual application queries, not theoretical ones
+2. **Include Frequency**: Query frequency is crucial for prioritization
+3. **Monitor Performance**: Validate recommendations with actual performance testing
+4. **Gradual Implementation**: Add indexes incrementally and monitor impact
+
+### Migration Planning
+1. **Test Migrations**: Always test on non-production environments first
+2. **Backup First**: Ensure complete backups before running migrations
+3. **Monitor Progress**: Watch for locks and performance impacts during execution
+4. **Rollback Ready**: Have rollback procedures tested and ready
+
+## Advanced Usage
+
+### Custom Selectivity Estimation
+The index optimizer uses pattern-based selectivity estimation. You can improve accuracy by providing cardinality estimates in your schema JSON:
+
+```json
+{
+  "columns": {
+    "status": {
+      "type": "VARCHAR(20)",
+      "cardinality_estimate": 5  # Only 5 distinct values
+    }
+  }
+}
+```
+
+### Zero-Downtime Migration Strategy
+For production systems, use the zero-downtime flag to generate expand-contract migrations:
+
+1. **Expand Phase**: Add new columns/tables without constraints
+2. **Dual Write**: Application writes to both old and new structures  
+3. **Backfill**: Populate new structures with existing data
+4. **Contract Phase**: Remove old structures after validation
+
+### Integration with CI/CD
+Integrate these tools into your deployment pipeline:
+
+```bash
+# Schema validation in CI
+python schema_analyzer.py --input schema.sql --output-format json | \
+  jq '.constraint_analysis.total_issues' | \
+  test $(cat) -eq 0 || exit 1
+
+# Generate migrations automatically
+python migration_generator.py \
+  --current prod_schema.json \
+  --target new_schema.json \
+  --zero-downtime \
+  --output migration.sql
+```
+
+## Troubleshooting
+
+### Common Issues
+
+**"No tables found in input file"**
+- Ensure SQL DDL uses standard CREATE TABLE syntax
+- Check for syntax errors in DDL
+- Verify file encoding (UTF-8 recommended)
+
+**"Invalid JSON schema"**  
+- Validate JSON syntax with a JSON validator
+- Ensure all required fields are present
+- Check that foreign key references use "table.column" format
+
+**"Analysis shows no issues but problems exist"**
+- Tools use heuristic analysis - review recommendations carefully
+- Some design decisions may be intentional (denormalization for performance)
+- Consider domain-specific requirements not captured by general rules
+
+### Performance Tips
+
+**Large Schemas:**
+- Use `--output-format json` for machine processing
+- Consider analyzing subsets of tables for very large schemas
+- Provide cardinality estimates for better index recommendations
+
+**Complex Queries:**
+- Include actual execution times in query patterns
+- Provide realistic frequency estimates
+- Consider seasonal or usage pattern variations
+
+## Contributing
+
+This is a self-contained skill with no external dependencies. To extend functionality:
+
+1. Follow the existing code patterns
+2. Maintain Python standard library only requirement
+3. Add comprehensive test cases for new features
+4. Update documentation and examples
+
+## License
+
+This database designer skill is part of the claude-skills collection and follows the same licensing terms.