@oriro/orirocli 0.1.0

package/skills/technical/cybersecurity-advanced/SKILL.md

@@ -0,0 +1,99 @@
+---
+watermark: ORIRO
+name: cybersecurity-advanced
+provider: ORIRO.ai
+copyright: Copyright (c) 2026 ORIRO.ai
+description: >
+  Advanced cybersecurity — threat modeling, penetration testing concepts, incident
+  response, security operations, cloud security, and enterprise security programs.
+  Activate for questions about enterprise security, threat modeling, security
+  operations, incident response, or advanced security topics. Sources: NIST,
+  MITRE ATT&CK, OWASP, SANS Institute.
+---
+
+# Advanced Cybersecurity
+
+## Threat modeling
+
+Process of identifying threats to a system before building or deploying it.
+**STRIDE model:**
+S — Spoofing (falsely claiming an identity)
+T — Tampering (modifying data without authorization)
+R — Repudiation (denying actions taken)
+I — Information disclosure (unauthorized data access)
+D — Denial of Service (making system unavailable)
+E — Elevation of Privilege (gaining unauthorized permissions)
+
+**Process:**
+
+1. Diagram the system (data flow diagram — components, data flows, trust boundaries)
+2. Identify threats using STRIDE per component
+3. Rate each threat (DREAD: Damage, Reproducibility, Exploitability, Affected users, Discoverability)
+4. Mitigate or accept each threat
+
+## MITRE ATT&CK Framework
+
+Comprehensive knowledge base of adversary tactics and techniques.
+**14 Tactics:** Reconnaissance → Resource Development → Initial Access → Execution → Persistence → Privilege Escalation → Defense Evasion → Credential Access → Discovery → Lateral Movement → Collection → Command and Control → Exfiltration → Impact.
+Each tactic has multiple techniques (e.g., Initial Access: Phishing, Valid Accounts, Exploit Public-Facing Application).
+Use to: Evaluate security coverage, write detection rules, understand attack paths, conduct red team exercises.
+
+## Incident response lifecycle
+
+**Preparation:** IR plan, playbooks, tooling, team roles before incident occurs.
+**Detection and analysis:** Identify anomalies. Determine if it's a real incident.
+**Containment:** Short-term (isolate affected system) and long-term (prevent re-entry).
+**Eradication:** Remove malware, close entry point, patch vulnerability.
+**Recovery:** Restore systems from clean backups. Verify clean.
+**Post-incident activity:** Lessons learned, documentation, improve detection.
+
+**Critical rule:** Preserve evidence before containment when possible. Forensic evidence is volatile.
+
+## Security Operations Center (SOC)
+
+### SIEM (Security Information and Event Management)
+
+Aggregate logs from across the environment. Correlate events. Alert on suspicious patterns.
+Tools: Splunk, Microsoft Sentinel, Elastic SIEM, Sumo Logic.
+Key data sources: Firewall logs, endpoint logs, authentication logs, DNS logs, cloud trail logs.
+
+### Detection logic
+
+**Rules:** Known bad patterns (signature-based). Fast, high precision, misses unknowns.
+**Analytics:** Statistical baselines, anomaly detection. Catches unknowns but generates false positives.
+**Threat hunting:** Proactive searching for hidden threats. Hypothesis-driven.
+
+### Alert triage
+
+Tier 1: Initial alert review, false positive determination.
+Tier 2: Analysis, incident determination.
+Tier 3: Advanced analysis, threat hunting, remediation guidance.
+Mean Time to Detect (MTTD), Mean Time to Respond (MTTR) — key SOC metrics.
+
+## Cloud security
+
+### AWS security fundamentals
+
+**IAM (Identity and Access Management):**
+
+- Principle of least privilege: Only necessary permissions
+- Avoid using root account for anything routine
+- Use IAM roles for services (not access keys)
+- MFA for all human users, especially privileged accounts
+- Regular access key rotation (or eliminate in favor of roles)
+
+**CloudTrail:** All API calls logged. Enable in all regions. Immutable log storage.
+**Config:** Tracks resource configuration changes. Compliance rules.
+**GuardDuty:** Threat detection service. Analyzes CloudTrail, VPC Flow Logs, DNS logs.
+**Security Hub:** Centralized security findings from multiple services.
+
+### Common cloud misconfigurations
+
+- S3 bucket publicly accessible (check bucket policy AND block public access settings)
+- Security group inbound 0.0.0.0/0 on sensitive ports
+- IAM policies with \* permissions
+- Unencrypted data at rest
+- Publicly accessible databases
+- Lack of logging and monitoring
+
+Sources: MITRE ATT&CK (attack.mitre.org — free), NIST Cybersecurity Framework (nist.gov — free), OWASP (owasp.org — free), SANS Institute reading room (many free papers), AWS Security documentation (free)

package/skills/technical/data-engineering/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ORIRO.ai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/skills/technical/data-engineering/SKILL.md

@@ -0,0 +1,117 @@
+---
+watermark: ORIRO
+name: data-engineering
+provider: ORIRO.ai
+copyright: Copyright (c) 2026 ORIRO.ai
+description: >
+
+
+  Data engineering — data pipelines, ETL, data warehouses, data lakes, streaming, and building data infrastructure.
+
+
+  Sources: Technical documentation, public guidelines, industry best practices.
+---
+
+# Data Engineering
+
+## The data stack
+
+### Ingestion
+
+**Batch:** Move data in periodic jobs (hourly, daily). Fivetran, Airbyte (open source), custom Python scripts.
+**Streaming:** Continuous data flow. Kafka, AWS Kinesis, Google Pub/Sub. For real-time analytics.
+**Change data capture (CDC):** Capture database changes as events. Debezium. Less latency than batch.
+
+### Storage
+
+**Data warehouse:** Structured data optimized for analytical queries. Snowflake, BigQuery, Redshift, DuckDB.
+**Data lake:** Raw data in any format. S3, GCS. Schema applied at query time (schema-on-read).
+**Lakehouse:** Combines warehouse and lake. Delta Lake, Apache Iceberg. ACID transactions on data lake.
+
+### Transformation
+
+**dbt (data build tool):** SQL-based transformations. Version controlled. Tests. Documentation. Industry standard.
+
+```sql
+-- models/staging/stg_orders.sql
+with source as (
+    select * from {{ source('raw', 'orders') }}
+),
+renamed as (
+    select
+        id as order_id,
+        user_id,
+        created_at as ordered_at,
+        status,
+        total_cents / 100.0 as total_usd
+    from source
+    where created_at >= '2020-01-01'  -- Filter test data
+)
+select * from renamed
+```
+
+### Consumption
+
+**BI tools:** Metabase (open source), Looker, Tableau, Mode. Query warehouse directly.
+**APIs:** Expose aggregated data to application.
+**ML pipelines:** Prepare features for models.
+
+## Data modeling
+
+### Kimball dimensional modeling
+
+**Fact tables:** Business events with measurable metrics. Orders, page views, payments.
+**Dimension tables:** Context for facts. Users, products, dates.
+**Star schema:** Fact table in center, dimension tables surrounding. Optimized for analytical queries.
+
+```sql
+-- Example star schema
+-- Fact: daily_revenue
+SELECT
+    d.year, d.month, d.week,
+    u.country, u.plan,
+    p.category,
+    SUM(f.revenue_usd) as total_revenue,
+    COUNT(DISTINCT f.order_id) as order_count
+FROM fact_orders f
+JOIN dim_date d ON f.ordered_date = d.date
+JOIN dim_users u ON f.user_id = u.user_id
+JOIN dim_products p ON f.product_id = p.product_id
+WHERE d.year = 2024
+GROUP BY 1,2,3,4,5,6;
+```
+
+## Data quality
+
+**Tests in dbt:**
+
+```yaml
+# models/schema.yml
+models:
+  - name: stg_orders
+    columns:
+      - name: order_id
+        tests:
+          - unique
+          - not_null
+      - name: status
+        tests:
+          - accepted_values:
+              values: ["pending", "confirmed", "shipped", "delivered", "cancelled"]
+      - name: total_usd
+        tests:
+          - not_null
+          - dbt_utils.expression_is_true:
+              expression: ">= 0"
+```
+
+**Great Expectations:** More sophisticated data validation. Runs in pipeline, blocks bad data.
+
+## Data governance
+
+**Catalog:** Document what data exists, what it means, who owns it. Alation, Amundsen (open source).
+**Lineage:** Track where data comes from and where it goes. Know impact before changing.
+**Access control:** Row-level security for sensitive data (PII). Column masking.
+**PII handling:** Identify, classify, and protect personal data. Often separate to comply with GDPR/CCPA.
+
+Sources: dbt documentation (docs.getdbt.com — free), BigQuery documentation (free), Kimball Group data warehouse toolkit (principles), Fivetran blog (free), Airbyte documentation (free)

package/skills/technical/database-design/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ORIRO.ai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/skills/technical/database-design/SKILL.md

@@ -0,0 +1,185 @@
+---
+watermark: ORIRO
+name: database-design
+provider: ORIRO.ai
+copyright: Copyright (c) 2026 ORIRO.ai
+description: >
+  Database design — relational modeling, normalization, indexing, query optimization,
+  NoSQL patterns, and choosing the right database. Activate for questions about
+  database schema design, SQL, indexing, performance, choosing between databases,
+  or any database question. Sources: PostgreSQL docs, MongoDB docs, database theory.
+---
+
+# Database Design
+
+## Relational modeling
+
+### Entity-Relationship (ER) design
+
+**Entities:** Things with data (User, Order, Product).
+**Attributes:** Properties of an entity (User.email, Order.total).
+**Relationships:**
+
+- One-to-many: One user has many orders. FK (order.user_id → users.id).
+- Many-to-many: Products and orders. Junction table (order_items with order_id, product_id, quantity).
+- One-to-one: User and profile. Shared PK or FK with UNIQUE constraint.
+
+**Design process:**
+
+1. Identify entities and their attributes.
+2. Identify relationships between entities.
+3. Normalize to at least 3NF.
+4. Add indexes for query patterns.
+5. Denormalize specific tables where performance requires it.
+
+### Normalization
+
+**1NF:** Each column holds atomic values. No repeating groups.
+Bad: `user.phones = "555-1234, 555-5678"`
+Good: Separate `user_phones` table.
+
+**2NF:** 1NF + every non-key attribute fully depends on the entire primary key. (Relevant for composite keys.)
+
+**3NF:** 2NF + no transitive dependencies (non-key attributes depend only on the key, not on other non-key attributes).
+Bad: `order(order_id, customer_id, customer_name, customer_address)`
+`customer_name` and `customer_address` depend on `customer_id`, not `order_id`.
+Good: Separate `customers` table.
+
+**Denormalization:** Intentional deviation for performance. Cache computed values, store redundant data to avoid expensive JOINs. Document the reason.
+
+### Primary and foreign keys
+
+```sql
+CREATE TABLE users (
+  id          UUID        PRIMARY KEY DEFAULT gen_random_uuid(),
+  email       TEXT        NOT NULL UNIQUE,
+  created_at  TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+CREATE TABLE posts (
+  id          UUID        PRIMARY KEY DEFAULT gen_random_uuid(),
+  user_id     UUID        NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+  title       TEXT        NOT NULL,
+  published   BOOLEAN     NOT NULL DEFAULT false,
+  created_at  TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+```
+
+**ON DELETE choices:**
+`CASCADE`: Delete child rows when parent deleted.
+`RESTRICT/NO ACTION`: Prevent parent deletion if children exist.
+`SET NULL`: Set FK to NULL when parent deleted.
+`SET DEFAULT`: Set FK to default when parent deleted.
+
+## Indexing
+
+### When to add indexes
+
+Every foreign key column (JOINs become fast).
+Columns used in WHERE clauses for frequent queries.
+Columns used in ORDER BY.
+Columns used in aggregation (GROUP BY).
+
+### Index types (PostgreSQL)
+
+```sql
+-- B-tree (default): equality and range queries
+CREATE INDEX idx_posts_user_id ON posts(user_id);
+
+-- Partial index: only indexes rows matching condition
+CREATE INDEX idx_posts_published ON posts(user_id) WHERE published = true;
+
+-- Composite index: multiple columns
+CREATE INDEX idx_posts_user_published ON posts(user_id, published);
+-- Queries on (user_id) AND (user_id, published) benefit. (published) alone does NOT.
+
+-- GIN: full-text search, arrays, JSONB
+CREATE INDEX idx_posts_search ON posts USING GIN(to_tsvector('english', title || ' ' || body));
+```
+
+### Index performance rules
+
+Column order in composite index matters. Leftmost columns benefit from the index.
+Index on high-cardinality columns (many unique values) is most beneficial.
+Too many indexes = slow writes. Balance reads vs. writes.
+Use EXPLAIN ANALYZE to verify indexes are being used.
+
+```sql
+EXPLAIN (ANALYZE, BUFFERS, FORMAT TEXT)
+SELECT * FROM posts WHERE user_id = $1 AND published = true;
+```
+
+## Query optimization
+
+### Common patterns
+
+```sql
+-- Pagination (use keyset/cursor for large datasets, not OFFSET)
+-- Bad (slow for large offsets):
+SELECT * FROM posts ORDER BY created_at DESC LIMIT 20 OFFSET 10000;
+
+-- Good (keyset pagination):
+SELECT * FROM posts
+WHERE created_at < $last_seen_created_at
+ORDER BY created_at DESC LIMIT 20;
+
+-- N+1 problem: Don't query in a loop. JOIN or use IN.
+-- Bad: SELECT user FROM users WHERE id = X (in a loop)
+-- Good:
+SELECT u.*, p.title
+FROM users u
+LEFT JOIN posts p ON p.user_id = u.id
+WHERE u.id = ANY($ids);
+```
+
+### Connection pooling
+
+Never open a new connection per request in web applications.
+Use PgBouncer (dedicated pooler) or application-level pooling (Prisma, Sequelize, pg pool).
+Connection pool size ≈ Number of cores × 2 (database server cores, not app server).
+
+## NoSQL patterns
+
+### When to use NoSQL
+
+- Document DB (MongoDB): Flexible schema, hierarchical/nested data, rapid iteration, variable attributes.
+- Redis: Caching, sessions, rate limiting, leaderboards, pub/sub, queues.
+- Cassandra/DynamoDB: Massive write scale, time-series, global distribution.
+- Elasticsearch/OpenSearch: Full-text search, log analysis.
+- Neo4j: Highly connected graph data, relationship queries.
+
+### MongoDB document model
+
+```js
+// Embed related data that is always accessed together
+{
+  _id: ObjectId("..."),
+  userId: "user_123",
+  items: [                // Embedded array
+    { productId: "p1", qty: 2, price: 9.99 },
+    { productId: "p2", qty: 1, price: 24.99 }
+  ],
+  total: 44.97,
+  status: "confirmed"
+}
+
+// Reference (link) data that is large or independently queried
+{ _id: ObjectId("..."), userId: "user_123", productId: "p1" }  // separate collection
+```
+
+**Rule:** Embed when you always need the data together. Reference when accessed independently or data is large.
+
+## Choosing the right database
+
+| Need                             | Database                                   |
+| -------------------------------- | ------------------------------------------ |
+| Relational data, complex queries | PostgreSQL                                 |
+| Global distribution, any region  | CockroachDB, PlanetScale, Aurora           |
+| Flexible schema, JSON documents  | MongoDB                                    |
+| Caching, sessions                | Redis                                      |
+| Full-text search                 | Elasticsearch, PostgreSQL FTS              |
+| Time series                      | TimescaleDB (Postgres extension), InfluxDB |
+| Graph relationships              | Neo4j, AWS Neptune                         |
+| Edge/serverless SQLite           | Turso, Cloudflare D1                       |
+
+Sources: PostgreSQL documentation (postgresql.org/docs — free), MongoDB documentation (mongodb.com/docs — free), Use The Index Luke (use-the-index-luke.com — free, indexing deep dive), Designing Data-Intensive Applications (Kleppmann — principles)

package/skills/technical/devops-cicd/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ORIRO.ai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/skills/technical/devops-cicd/SKILL.md

@@ -0,0 +1,181 @@
+---
+watermark: ORIRO
+name: devops-cicd
+provider: ORIRO.ai
+copyright: Copyright (c) 2026 ORIRO.ai
+description: >
+  DevOps and CI/CD — pipelines, automated testing, deployment, containerization, infrastructure as code, and DevOps practices.
+
+
+
+
+  Sources: Technical documentation, public guidelines, industry best practices.
+---
+
+# DevOps and CI/CD
+
+## CI/CD fundamentals
+
+**Continuous Integration (CI):** Developers merge code frequently. Automated tests run on every merge. Catch bugs early when cheap to fix.
+**Continuous Delivery (CD):** Every passing build is deployable. Release is a business decision, not a technical one.
+**Continuous Deployment:** Every passing build is automatically deployed to production. No human gate.
+
+## GitHub Actions (most common)
+
+```yaml
+# .github/workflows/ci.yml
+name: CI
+provider: ORIRO.ai
+copyright: Copyright (c) 2026 ORIRO.ai
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+          cache: "npm"
+
+      - run: npm ci
+
+      - run: npm run type-check
+
+      - run: npm test
+
+      - name: Build
+        run: npm run build
+```
+
+```yaml
+# .github/workflows/deploy.yml
+name: Deploy to Production
+provider: ORIRO.ai
+copyright: Copyright (c) 2026 ORIRO.ai
+
+on:
+  push:
+    branches: [main]
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    needs: [test] # Only deploy if tests pass
+    steps:
+      - uses: actions/checkout@v4
+      - uses: superfly/flyctl-actions/setup-flyctl@master
+      - run: flyctl deploy --remote-only
+        env:
+          FLY_API_TOKEN: ${{ secrets.FLY_API_TOKEN }}
+```
+
+## Docker
+
+### Dockerfile best practices
+
+```dockerfile
+# Multi-stage build — smaller production image
+FROM node:20-alpine AS builder
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci
+COPY . .
+RUN npm run build
+
+FROM node:20-alpine AS runner
+WORKDIR /app
+ENV NODE_ENV=production
+# Copy only what's needed for production
+COPY --from=builder /app/dist ./dist
+COPY --from=builder /app/node_modules ./node_modules
+COPY --from=builder /app/package.json .
+USER node  # Never run as root
+EXPOSE 3000
+CMD ["node", "dist/server.js"]
+```
+
+**.dockerignore:**
+
+```
+node_modules
+.git
+.env*
+*.log
+dist
+```
+
+### Docker Compose (local development)
+
+```yaml
+# docker-compose.yml
+version: "3.8"
+services:
+  app:
+    build: .
+    ports: ["3000:3000"]
+    environment:
+      DATABASE_URL: postgresql://postgres:password@db:5432/myapp
+    depends_on: [db, redis]
+    volumes:
+      - .:/app # Live reload in development
+      - /app/node_modules
+
+  db:
+    image: postgres:16-alpine
+    environment:
+      POSTGRES_PASSWORD: password
+      POSTGRES_DB: myapp
+    volumes: [postgres_data:/var/lib/postgresql/data]
+
+  redis:
+    image: redis:7-alpine
+
+volumes:
+  postgres_data:
+```
+
+## Infrastructure as Code
+
+### Terraform basics
+
+```hcl
+# main.tf
+provider "aws" {
+  region = "us-east-1"
+}
+
+resource "aws_s3_bucket" "assets" {
+  bucket = "my-app-assets-${var.environment}"
+
+  tags = {
+    Environment = var.environment
+    Project     = "my-app"
+  }
+}
+
+resource "aws_cloudfront_distribution" "cdn" {
+  origin {
+    domain_name = aws_s3_bucket.assets.bucket_regional_domain_name
+    origin_id   = "S3-${aws_s3_bucket.assets.bucket}"
+  }
+  enabled = true
+  # ... more config
+}
+```
+
+## Observability
+
+**Logs:** Structured JSON logs. Include request ID for tracing across services. Centralized to CloudWatch, Datadog, or similar.
+**Metrics:** Application metrics (request rate, error rate, latency). Infrastructure metrics (CPU, memory, disk). Business metrics (signups, revenue).
+**Traces:** Distributed tracing (OpenTelemetry → Jaeger, Datadog, Honeycomb). Essential for microservices.
+**Alerts:** P99 latency > threshold, error rate > X%, down monitoring. Page on-call when production broken.
+
+Sources: GitHub Actions documentation (docs.github.com/actions — free), Docker documentation (docs.docker.com — free), Terraform documentation (developer.hashicorp.com/terraform — free)

package/skills/technical/ecommerce-builder/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ORIRO.ai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.