@fenixforce/edition-pro 0.1.0

package/skills/builtin/docker-deployment/SKILL.md

@@ -0,0 +1,243 @@
+---
+name: docker-deployment
+description: "Use this skill when the user asks to containerize an application, write a Dockerfile, create Docker Compose services, optimize container images, or deploy using Docker. Triggers: 'Docker', 'Dockerfile', 'docker-compose', 'containerize', 'container', 'image', 'deploy with Docker', 'multi-stage build', or any request involving container-based deployment."
+license: MIT
+---
+
+# Docker Deployment
+
+## What This Skill Does
+
+Containerize applications for consistent deployment. Dockerfiles, Docker Compose, multi-stage builds, image optimization, health checks, and production container patterns.
+
+## Before You Start
+
+1. **Identify the runtime:** Bun, Node.js, Python, Go, etc.
+2. **Identify dependencies:** Database, Redis, message queue, etc.
+3. **Clarify environment:** Local development, staging, or production?
+
+## Dockerfile Patterns
+
+### Bun Application (Multi-Stage)
+```dockerfile
+FROM oven/bun:1 AS base
+WORKDIR /app
+
+# Install dependencies (cached layer)
+FROM base AS deps
+COPY package.json bun.lock* ./
+RUN bun install --frozen-lockfile --production
+
+# Build (if needed)
+FROM base AS build
+COPY package.json bun.lock* ./
+RUN bun install --frozen-lockfile
+COPY . .
+RUN bun run build
+
+# Production image
+FROM base AS runtime
+COPY --from=deps /app/node_modules ./node_modules
+COPY --from=build /app/dist ./dist
+COPY --from=build /app/package.json ./
+
+USER bun
+EXPOSE 3000
+HEALTHCHECK --interval=30s --timeout=3s --start-period=10s \
+  CMD curl -f http://localhost:3000/health || exit 1
+
+CMD ["bun", "run", "dist/index.js"]
+```
+
+### Node.js Application (Multi-Stage)
+```dockerfile
+FROM node:20-alpine AS base
+WORKDIR /app
+
+FROM base AS deps
+COPY package.json package-lock.json ./
+RUN npm ci --only=production
+
+FROM base AS build
+COPY package.json package-lock.json ./
+RUN npm ci
+COPY . .
+RUN npm run build
+
+FROM base AS runtime
+RUN addgroup --system --gid 1001 nodejs && \
+    adduser --system --uid 1001 appuser
+COPY --from=deps /app/node_modules ./node_modules
+COPY --from=build /app/dist ./dist
+COPY --from=build /app/package.json ./
+
+USER appuser
+EXPOSE 3000
+HEALTHCHECK --interval=30s --timeout=3s --start-period=10s \
+  CMD wget --no-verbose --tries=1 --spider http://localhost:3000/health || exit 1
+
+CMD ["node", "dist/index.js"]
+```
+
+### .dockerignore
+```
+node_modules
+.git
+.env
+*.md
+tests
+.github
+docker-compose*.yml
+Dockerfile
+.dockerignore
+```
+
+## Docker Compose
+
+### Development Environment
+```yaml
+services:
+  app:
+    build:
+      context: .
+      target: build
+    ports:
+      - "3000:3000"
+    volumes:
+      - .:/app
+      - /app/node_modules
+    environment:
+      - NODE_ENV=development
+      - DATABASE_URL=postgresql://appuser:devpass@db:5432/appdb
+    depends_on:
+      db:
+        condition: service_healthy
+
+  db:
+    image: postgres:16-alpine
+    environment:
+      POSTGRES_DB: appdb
+      POSTGRES_USER: appuser
+      POSTGRES_PASSWORD: devpass
+    ports:
+      - "5432:5432"
+    volumes:
+      - pgdata:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U appuser -d appdb"]
+      interval: 5s
+      timeout: 3s
+      retries: 5
+
+  redis:
+    image: redis:7-alpine
+    ports:
+      - "6379:6379"
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 5s
+      timeout: 3s
+
+volumes:
+  pgdata:
+```
+
+### Production Docker Compose
+```yaml
+services:
+  app:
+    build:
+      context: .
+      target: runtime
+    restart: unless-stopped
+    ports:
+      - "3000:3000"
+    environment:
+      - NODE_ENV=production
+      - DATABASE_URL=${DATABASE_URL}
+    depends_on:
+      db:
+        condition: service_healthy
+    deploy:
+      resources:
+        limits:
+          memory: 512M
+          cpus: "1.0"
+
+  db:
+    image: postgres:16-alpine
+    restart: unless-stopped
+    environment:
+      POSTGRES_DB: ${DB_NAME}
+      POSTGRES_USER: ${DB_USER}
+      POSTGRES_PASSWORD: ${DB_PASSWORD}
+    volumes:
+      - pgdata:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U ${DB_USER} -d ${DB_NAME}"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+    deploy:
+      resources:
+        limits:
+          memory: 256M
+
+volumes:
+  pgdata:
+```
+
+## Image Optimization
+
+### Size Reduction Checklist
+- Use Alpine base images (`node:20-alpine`, `python:3.12-alpine`)
+- Multi-stage builds: build stage has dev tools, runtime stage has only production deps
+- `.dockerignore` excludes tests, docs, git history
+- Combine RUN commands to reduce layers
+- Clean package manager cache in the same layer as install
+
+### Layer Caching
+Order instructions from least to most frequently changing:
+```dockerfile
+FROM node:20-alpine        # 1. Base (rarely changes)
+RUN apk add --no-cache curl # 2. System deps (rarely)
+COPY package.json ./        # 3. Package files (on dep update)
+RUN npm ci                  # 4. Install (on dep update)
+COPY . .                    # 5. Source (every build)
+RUN npm run build
+```
+
+## Security
+
+- Never run as root in production (use `USER` directive)
+- Never copy `.env` files into images
+- Pin base image versions (`node:20.11-alpine` not `node:latest`)
+- Scan images: `docker scout cves <image>`
+- No secrets in build args or environment variables baked into the image
+
+## Rules
+
+- Every Dockerfile must have a HEALTHCHECK
+- Every production image must run as non-root user
+- Every docker-compose.yml must have health checks on databases
+- Always use multi-stage builds for compiled languages and TypeScript
+- Always include `.dockerignore`
+- Never use `latest` tag for base images in production
+- Environment variables for all configuration (12-factor app)
+- Resource limits set on all production containers
+
+## Verification
+
+1. `docker build .` succeeds with no errors
+2. `docker compose up` starts all services
+3. Health checks pass within the configured start period
+4. Application responds to requests through the exposed port
+5. `docker images` shows the runtime image is under 200MB
+6. Container runs as non-root user
+
+## Integration with Other Skills
+
+- **backend-development:** Containerize the server it produces
+- **fullstack-project:** Docker Compose is part of project scaffolding
+- **server-management:** Docker runs on the server this skill configures
+- **ci-cd-pipelines:** Build and push images in CI

package/skills/builtin/docx-generation/SKILL.md

@@ -0,0 +1,135 @@
+---
+name: docx-generation
+description: "Use this skill when the user asks to create, edit, or manipulate Word documents (.docx files). Triggers: 'Word doc', 'word document', '.docx', 'report', 'memo', 'letter', 'template', or requests for professional documents with formatting like tables of contents, headings, page numbers, or letterheads."
+license: MIT
+---
+
+# DOCX Generation
+
+## What This Skill Does
+
+Create and edit Word documents using the `docx` npm package (MIT, pure JavaScript, runs on Bun).
+
+## Dependencies
+
+```bash
+bun add docx
+```
+
+## Creation
+
+```typescript
+import { Document, Packer, Paragraph, TextRun, HeadingLevel, Table, TableRow, TableCell, WidthType, AlignmentType, Header, Footer, PageNumber, NumberFormat, ImageRun, BorderStyle } from "docx";
+import { writeFile, readFile } from "fs/promises";
+
+// Create document
+const doc = new Document({
+  sections: [{
+    properties: {
+      page: {
+        margin: { top: 1440, right: 1440, bottom: 1440, left: 1440 }, // 1 inch = 1440 twips
+      },
+    },
+    headers: {
+      default: new Header({
+        children: [new Paragraph({ text: "Company Name", alignment: AlignmentType.RIGHT })],
+      }),
+    },
+    footers: {
+      default: new Footer({
+        children: [new Paragraph({
+          children: [
+            new TextRun("Page "),
+            new TextRun({ children: [PageNumber.CURRENT] }),
+            new TextRun(" of "),
+            new TextRun({ children: [PageNumber.TOTAL_PAGES] }),
+          ],
+          alignment: AlignmentType.CENTER,
+        })],
+      }),
+    },
+    children: [
+      new Paragraph({ text: "Document Title", heading: HeadingLevel.HEADING_1 }),
+      new Paragraph({
+        children: [
+          new TextRun({ text: "Bold text", bold: true }),
+          new TextRun(" and normal text."),
+        ],
+      }),
+      // Table
+      new Table({
+        rows: [
+          new TableRow({
+            children: [
+              new TableCell({ children: [new Paragraph("Header 1")], width: { size: 50, type: WidthType.PERCENTAGE } }),
+              new TableCell({ children: [new Paragraph("Header 2")], width: { size: 50, type: WidthType.PERCENTAGE } }),
+            ],
+          }),
+          new TableRow({
+            children: [
+              new TableCell({ children: [new Paragraph("Cell 1")] }),
+              new TableCell({ children: [new Paragraph("Cell 2")] }),
+            ],
+          }),
+        ],
+      }),
+    ],
+  }],
+});
+
+// Write to file
+const buffer = await Packer.toBuffer(doc);
+await writeFile("output.docx", buffer);
+```
+
+## Reading .docx Content
+
+Use the `mammoth` npm package to extract text from existing .docx files:
+
+```typescript
+import mammoth from "mammoth";
+
+const result = await mammoth.extractRawText({ path: "input.docx" });
+const text = result.value; // Plain text content
+
+// Or convert to HTML
+const htmlResult = await mammoth.convertToHtml({ path: "input.docx" });
+const html = htmlResult.value;
+```
+
+```bash
+bun add mammoth
+```
+
+## Editing Existing Documents
+
+The `docx` package creates new documents. To modify existing .docx files, read content with mammoth, then generate a new document with modifications using docx. For find-and-replace operations, read the raw XML from the ZIP using `adm-zip`:
+
+```typescript
+import AdmZip from "adm-zip";
+
+const zip = new AdmZip("input.docx");
+let content = zip.readAsText("word/document.xml");
+content = content.replace(/OLD_TEXT/g, "NEW_TEXT");
+zip.updateFile("word/document.xml", Buffer.from(content));
+zip.writeZip("output.docx");
+```
+
+```bash
+bun add adm-zip
+bun add -d @types/adm-zip
+```
+
+## Key Elements
+
+Headers, footers, page numbers, tables, bullet lists, numbered lists, images (via ImageRun with base64 data), hyperlinks, page breaks, sections with different orientations, bookmarks.
+
+## Rules
+
+- Use the `docx` npm package for creation (pure JS, Bun-compatible)
+- Use `mammoth` for reading existing documents
+- Use `adm-zip` for raw XML manipulation of existing .docx
+- Include page numbers for documents over 3 pages
+- Use consistent heading hierarchy (H1, H2, H3, no skipping)
+- Test the output file opens without errors
+- All packages are MIT licensed and run on Bun without Python.

package/skills/builtin/dry-run-harness/SKILL.md

@@ -0,0 +1,61 @@
+# Dry-Run Harness
+
+## Pattern: Propose -> Review -> Execute
+
+1. **Propose**: agent generates the action plan (what it would do, parameters, expected outcome)
+2. **Review**: plan and logs surfaced to user. Side effects listed explicitly.
+3. **Execute**: only after explicit user approval. If rejected, agent revises plan.
+
+## When to Use
+
+- Deploying to production
+- Sending emails or messages
+- Modifying databases
+- Deleting files or resources
+- Making API calls with side effects
+- Any action that cannot be undone
+
+## Dry-Run Output Format
+
+```markdown
+## Proposed Action
+**Action**: [what will happen]
+**Parameters**: [inputs]
+**Expected Outcome**: [what should result]
+**Side Effects**: [what else changes]
+**Reversible**: [yes/no, and how to reverse if yes]
+
+## Approve? [waiting for user confirmation]
+```
+
+## Incident-to-Eval Synthesis
+
+Convert failing agent runs into regression eval cases:
+
+### Capture
+When an agent run fails (user rejection, runtime error, incorrect output):
+1. Record the full action sequence (inputs, tool calls, outputs)
+2. Record the failure point and failure reason
+3. Record the user's correction or expected outcome
+
+### Synthesize Eval Case
+```markdown
+## Eval: [auto-generated-id]
+**Source**: incident on [date]
+**Input**: [original user request]
+**Expected behavior**: [what should have happened]
+**Failure mode**: [what actually happened]
+**Passing criteria**: [specific conditions for pass]
+```
+
+### Integrate
+- Eval cases stored in `__evals__/incidents/`
+- Run as part of the dry-run test suite
+- Each eval case tests that the same failure doesn't recur
+- Review eval cases quarterly; retire those testing fixed bugs
+
+## Rules
+
+- Never execute side-effect actions without user approval in dry-run mode
+- Always list ALL side effects, not just the primary action
+- If the user rejects, ask what to change rather than re-proposing the same plan

package/skills/builtin/editor/SKILL.md

@@ -0,0 +1,44 @@
+# Editor
+
+## Review Layers
+
+1. **Correctness**: grammar, spelling, punctuation, factual accuracy
+2. **Clarity**: ambiguous sentences, jargon without definition, logical flow
+3. **Consistency**: tense, voice, terminology, formatting, capitalization
+4. **Tone**: matches intended audience and purpose
+5. **Structure**: logical flow, paragraph transitions, heading hierarchy
+
+## Readability Checks
+
+- Sentence length: average under 20 words
+- Paragraph length: under 5 sentences
+- Passive voice: under 15% of sentences
+- Jargon: defined on first use or avoided for general audiences
+
+## Output Format
+
+```markdown
+## Summary
+[Overall assessment: strengths, main issues]
+
+## Critical Issues
+- [Issue]: [specific location] → [suggested fix]
+
+## Style Improvements
+- [Suggestion]: [why it improves the text]
+
+## Consistency Notes
+- [Inconsistency found]: [recommendation]
+
+## Readability Score
+- Average sentence length: [N words]
+- Passive voice: [N%]
+- Jargon density: [low/medium/high]
+```
+
+## Rules
+
+- Preserve the author's voice while fixing issues
+- Suggest, don't rewrite (unless asked to rewrite)
+- Explain WHY a change improves the text
+- Flag factual claims that seem wrong but don't correct without verification

package/skills/builtin/email-drafter/SKILL.md

@@ -0,0 +1,42 @@
+# Email Drafter
+
+## Structure
+
+1. **Subject**: under 50 chars, specific, creates urgency or curiosity
+2. **Opening**: one sentence establishing context or connection
+3. **Body**: the ask or information, 2-3 short paragraphs max
+4. **CTA**: single clear next step
+5. **Close**: appropriate sign-off for the relationship
+
+## Tone Calibration
+
+- **Executive**: direct, data-driven, bottom-line-up-front
+- **Colleague**: conversational, collaborative
+- **Client**: professional, value-focused
+- **Cold outreach**: personalized hook, brief, specific ask
+- **Follow-up**: reference previous, add new value, don't just "checking in"
+
+## Subject Line Guidelines
+
+- Under 50 characters
+- Specific over clever
+- Include deadline or key detail when relevant
+- Avoid all-caps, excessive punctuation, spam triggers
+
+## Output Format
+
+```markdown
+**Subject**: [subject line]
+
+[Email body]
+
+**Notes**: [tone rationale, alternatives considered]
+```
+
+## Rules
+
+- One CTA per email
+- Subject lines: specific over clever
+- Preview text (first ~90 chars) matters as much as subject
+- Never "just checking in" without adding value
+- Read it from the recipient's perspective before sending

package/skills/builtin/error-handling/SKILL.md

@@ -0,0 +1,82 @@
+---
+name: error-handling
+description: "Use this skill when implementing error handling patterns, designing error hierarchies, or working with Result/Option types. Triggers: 'error handling', 'try catch', 'Result type', 'error boundary', 'exception', 'error hierarchy', or requests to improve how code handles failures."
+license: MIT
+---
+
+# Error Handling Patterns
+
+## What This Skill Does
+
+Implement robust error handling. Typed error hierarchies, Result<T,E> patterns, error boundaries, and consistent error reporting.
+
+## TypeScript Error Hierarchy
+
+```typescript
+class AppError extends Error {
+  constructor(
+    public code: string,
+    message: string,
+    public statusCode: number = 500,
+    public details?: unknown
+  ) {
+    super(message);
+    this.name = "AppError";
+  }
+}
+
+class ValidationError extends AppError {
+  constructor(message: string, details?: unknown) {
+    super("VALIDATION_ERROR", message, 422, details);
+  }
+}
+
+class NotFoundError extends AppError {
+  constructor(resource: string, id: string) {
+    super("NOT_FOUND", `${resource} '${id}' not found`, 404);
+  }
+}
+
+class UnauthorizedError extends AppError {
+  constructor(message = "Authentication required") {
+    super("UNAUTHORIZED", message, 401);
+  }
+}
+```
+
+## Result Pattern (no exceptions for expected failures)
+
+```typescript
+type Result<T, E = Error> =
+  | { ok: true; value: T }
+  | { ok: false; error: E };
+
+function ok<T>(value: T): Result<T, never> {
+  return { ok: true, value };
+}
+
+function err<E>(error: E): Result<never, E> {
+  return { ok: false, error };
+}
+
+// Usage
+function parseEmail(input: string): Result<string, string> {
+  if (!input.includes("@")) return err("Invalid email format");
+  return ok(input.toLowerCase().trim());
+}
+
+const result = parseEmail(input);
+if (!result.ok) {
+  return Response.json({ error: result.error }, { status: 422 });
+}
+const email = result.value;
+```
+
+## Rules
+
+- Use exceptions for unexpected failures (bugs, infrastructure)
+- Use Result types for expected failures (validation, business rules)
+- Never catch and swallow errors silently
+- Log errors with full context (stack trace, request data, user ID)
+- Never expose internal error details to users in production
+- Every catch block must either handle the error or re-throw with context