@fenixforce/edition-pro 0.1.0

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

@@ -0,0 +1,169 @@
+---
+name: pdf-generation
+description: "Use this skill when the user asks to create, fill, merge, split, or manipulate PDF files. Triggers: 'PDF', '.pdf', 'form fill', 'merge PDFs', 'split PDF', 'watermark', 'OCR', or any request involving PDF manipulation."
+license: MIT
+---
+
+# PDF Generation
+
+## What This Skill Does
+
+Create and manipulate PDFs using `pdf-lib` (MIT, pure JavaScript, runs on Bun). Extract text using `pdf-parse`.
+
+## Dependencies
+
+```bash
+bun add pdf-lib
+bun add pdf-parse
+```
+
+## Creating PDFs
+
+```typescript
+import { PDFDocument, rgb, StandardFonts, PageSizes } from "pdf-lib";
+import { writeFile, readFile } from "fs/promises";
+
+const doc = await PDFDocument.create();
+doc.setTitle("Document Title");
+doc.setAuthor("Fenix Agent");
+
+const font = await doc.embedFont(StandardFonts.Helvetica);
+const boldFont = await doc.embedFont(StandardFonts.HelveticaBold);
+
+const page = doc.addPage(PageSizes.Letter); // [612, 792]
+const { width, height } = page.getSize();
+
+// Title
+page.drawText("Document Title", {
+  x: 50, y: height - 72,
+  size: 24, font: boldFont, color: rgb(0.1, 0.1, 0.12),
+});
+
+// Body text
+page.drawText("This is a paragraph of body text.", {
+  x: 50, y: height - 120,
+  size: 12, font, color: rgb(0.2, 0.2, 0.2),
+  maxWidth: width - 100,
+  lineHeight: 16,
+});
+
+// Draw line separator
+page.drawLine({
+  start: { x: 50, y: height - 100 },
+  end: { x: width - 50, y: height - 100 },
+  thickness: 1, color: rgb(0.8, 0.8, 0.8),
+});
+
+// Add second page
+const page2 = doc.addPage(PageSizes.Letter);
+page2.drawText("Page 2 content", { x: 50, y: height - 72, size: 12, font });
+
+const pdfBytes = await doc.save();
+await writeFile("output.pdf", pdfBytes);
+```
+
+## Merging PDFs
+
+```typescript
+import { PDFDocument } from "pdf-lib";
+
+const merged = await PDFDocument.create();
+const files = ["file1.pdf", "file2.pdf", "file3.pdf"];
+
+for (const file of files) {
+  const bytes = await readFile(file);
+  const source = await PDFDocument.load(bytes);
+  const pages = await merged.copyPages(source, source.getPageIndices());
+  pages.forEach(page => merged.addPage(page));
+}
+
+await writeFile("merged.pdf", await merged.save());
+```
+
+## Splitting PDFs
+
+```typescript
+const source = await PDFDocument.load(await readFile("input.pdf"));
+
+// Extract pages 0-4 into a new document
+const part1 = await PDFDocument.create();
+const pages = await part1.copyPages(source, [0, 1, 2, 3, 4]);
+pages.forEach(p => part1.addPage(p));
+await writeFile("part1.pdf", await part1.save());
+```
+
+## Filling PDF Forms
+
+```typescript
+const bytes = await readFile("form.pdf");
+const doc = await PDFDocument.load(bytes);
+const form = doc.getForm();
+
+// Fill fields by name
+form.getTextField("name").setText("John Doe");
+form.getTextField("email").setText("john@example.com");
+form.getCheckBox("agree").check();
+form.getDropdown("country").select("United States");
+
+// Flatten (make fields non-editable)
+form.flatten();
+
+await writeFile("filled.pdf", await doc.save());
+```
+
+## Adding Watermark
+
+```typescript
+const doc = await PDFDocument.load(await readFile("input.pdf"));
+const font = await doc.embedFont(StandardFonts.HelveticaBold);
+
+for (const page of doc.getPages()) {
+  const { width, height } = page.getSize();
+  page.drawText("DRAFT", {
+    x: width / 4, y: height / 3,
+    size: 72, font,
+    color: rgb(0.9, 0.9, 0.9),
+    rotate: { type: "degrees" as const, angle: 45 },
+    opacity: 0.3,
+  });
+}
+
+await writeFile("watermarked.pdf", await doc.save());
+```
+
+## Extracting Text
+
+```typescript
+import pdf from "pdf-parse";
+
+const buffer = await readFile("input.pdf");
+const data = await pdf(buffer);
+console.log(data.text);     // All text content
+console.log(data.numpages);  // Page count
+console.log(data.info);      // Metadata
+```
+
+## Embedding Images
+
+```typescript
+const imageBytes = await readFile("logo.png");
+const image = await doc.embedPng(imageBytes);
+// or: const image = await doc.embedJpg(imageBytes);
+
+const dims = image.scale(0.5); // Scale to 50%
+page.drawImage(image, {
+  x: 50, y: height - 100,
+  width: dims.width, height: dims.height,
+});
+```
+
+## Rules
+
+- Use `pdf-lib` for creation, merging, splitting, form filling, watermarks (pure JS, Bun-compatible)
+- Use `pdf-parse` for text extraction (pure JS, Bun-compatible)
+- Always embed fonts (never rely on system fonts for portability)
+- Always set metadata (title, author, creation date)
+- For form filling, flatten after filling unless user needs editable output
+- Test output opens in multiple PDF readers
+- All packages are MIT licensed, no Python required
+- For OCR on scanned PDFs, use Vision-LLM through Fenix provider abstraction (Task 3.9), not Tesseract.

package/skills/builtin/personal-finance/SKILL.md

@@ -0,0 +1,17 @@
+# Personal Finance
+## Capabilities
+- Parse bank statements and categorize expenses
+- Build monthly budgets with recommended allocations
+- Track spending against budget categories
+- Calculate savings rate and project goal timelines
+- Identify spending patterns and suggest optimizations
+
+## Budget Template (50/30/20)
+- **50% Needs**: rent, utilities, groceries, insurance, minimum debt payments
+- **30% Wants**: entertainment, dining out, subscriptions, hobbies
+- **20% Savings**: emergency fund, retirement, debt payoff above minimums
+
+## Rules
+- Categorize every transaction (no "miscellaneous" bucket above 5%)
+- Flag recurring subscriptions the user may have forgotten
+- Note: informational guidance, not professional financial advice.

package/skills/builtin/pev-workflow/SKILL.md

@@ -0,0 +1,62 @@
+# Plan -> Execute -> Verify
+
+## The Three Stages
+
+### Plan
+Create detailed plan with expected outcomes for each step. Plan reviewed before execution begins.
+
+### Execute
+Follow the plan. If unexpected complexity discovered, return to planning rather than improvising.
+
+### Verify
+Dedicated verification step after execution. Verifier operates independently:
+- Does NOT trust the executor's self-report
+- Reads actual output/code independently
+- Checks against original plan's expected outcomes
+- Reports pass/fail with specific evidence
+
+## Self-Correcting Loop
+
+If verify fails:
+1. Verifier produces specific failure report
+2. Return to Plan with failure report as input
+3. New plan addresses specific failures
+4. Execute revised plan
+5. Verify again
+6. Max 3 correction cycles, then escalate to user
+
+## Artifact Production
+
+Each PEV cycle produces:
+- `plan.md` — detailed plan with expected outcomes
+- Execution log — what was actually done
+- Verification report — pass/fail per step with evidence
+
+## Output Format
+
+```markdown
+## Plan
+### Step 1: [Title]
+**Action**: [what to do]
+**Expected outcome**: [what should result]
+
+## Execution Log
+### Step 1: [Title]
+**Status**: complete
+**Actual outcome**: [what happened]
+
+## Verification Report
+### Step 1: [Title]
+**Expected**: [from plan]
+**Actual**: [from execution]
+**Verdict**: PASS / FAIL
+**Evidence**: [specific proof]
+
+## Overall: PASS / FAIL (cycle N of 3)
+```
+
+## Rules
+
+- Verification is always a separate step, never combined with execution
+- Verifier must distrust executor's report
+- Each PEV cycle produces artifacts: plan.md, execution log, verification report

package/skills/builtin/planning-with-files/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: planning-with-files
+description: "Use this skill for multi-step tasks, complex projects, or any work requiring a plan before execution. Triggers: 'plan', 'multi-step', 'project', 'architect', 'complex task', 'break this down', or any task with 3+ steps that benefits from written planning."
+license: MIT
+---
+
+# Planning with Files
+
+## What This Skill Does
+
+Use filesystem-persisted plans for multi-step work. Write the plan before executing. Track progress. Capture findings. Recover context across sessions.
+
+## Files
+
+```
+workspace/
+├── task_plan.md      # The plan with checkable items
+├── findings.md       # Discoveries and decisions made during work
+├── progress.md       # Current status and blockers
+└── scratchpad.md     # Temporary notes, rough ideas
+```
+
+## Plan Format
+
+```markdown
+# Task: [What we're building]
+
+## Goal
+One sentence describing the end state.
+
+## Steps
+- [ ] Step 1: [specific, actionable, completable in one session]
+- [ ] Step 2: [depends on step 1 output]
+- [ ] Step 3: [can be done in parallel with step 2]
+
+## Decisions Made
+- Decision 1: [what] because [why]
+
+## Open Questions
+- Question 1: [what we need to find out]
+```
+
+## Rules
+
+- Write the plan BEFORE executing any steps
+- Each step must be specific enough that you could hand it to someone else
+- Update progress.md after completing each step
+- Record findings as you discover them (don't lose context)
+- Review the plan after every 3 steps and adjust if needed
+- Steps should be 2-5 minutes each. If longer, break them down.
+
+## Dynamic Scaffolding
+
+Start with minimal plan structure. Add complexity only as the task reveals it:
+- Simple task (1-3 steps): single task_plan.md with checklist
+- Medium task (4-10 steps): task_plan.md + findings.md
+- Complex task (10+ steps): full workspace with task_plan.md, findings.md, progress.md, decisions.md, scratchpad.md
+
+Don't create a 5-file workspace for a 2-step task. Don't try to squeeze a 15-step project into a single checklist.

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

@@ -0,0 +1,117 @@
+---
+name: pptx-generation
+description: "Use this skill when the user asks to create or edit PowerPoint presentations (.pptx). Triggers: 'presentation', 'slides', 'deck', 'PowerPoint', '.pptx', 'pitch deck', 'slide deck', or requests for visual presentations with layouts, speaker notes, and diagrams."
+license: MIT
+---
+
+# PPTX Generation
+
+## What This Skill Does
+
+Create PowerPoint presentations using the `pptxgenjs` npm package (MIT, pure JavaScript, runs on Bun).
+
+## Dependencies
+
+```bash
+bun add pptxgenjs
+```
+
+## Creation
+
+```typescript
+import PptxGenJS from "pptxgenjs";
+
+const pres = new PptxGenJS();
+pres.layout = "LAYOUT_16x9";
+pres.author = "Fenix Agent";
+pres.title = "Presentation Title";
+
+// Title slide
+const titleSlide = pres.addSlide();
+titleSlide.addText("Presentation Title", {
+  x: 0.5, y: 1.5, w: 9, h: 1.5,
+  fontSize: 36, bold: true, color: "1a1a2e",
+  align: "center",
+});
+titleSlide.addText("Subtitle or Author", {
+  x: 0.5, y: 3.2, w: 9, h: 0.8,
+  fontSize: 18, color: "666666",
+  align: "center",
+});
+titleSlide.addNotes("Speaker notes for the title slide go here.");
+
+// Content slide with bullets
+const contentSlide = pres.addSlide();
+contentSlide.addText("Section Title", {
+  x: 0.5, y: 0.3, w: 9, h: 0.8,
+  fontSize: 28, bold: true, color: "1a1a2e",
+});
+contentSlide.addText(
+  [
+    { text: "First point", options: { bullet: true, fontSize: 18 } },
+    { text: "Second point", options: { bullet: true, fontSize: 18 } },
+    { text: "Third point", options: { bullet: true, fontSize: 18 } },
+  ],
+  { x: 0.8, y: 1.5, w: 8.2, h: 4, valign: "top" }
+);
+contentSlide.addNotes("Key talking points for this slide.");
+
+// Slide with image (from file or base64)
+const imageSlide = pres.addSlide();
+imageSlide.addImage({ path: "chart.png", x: 1, y: 1.5, w: 8, h: 4.5 });
+// Or from base64:
+// imageSlide.addImage({ data: "data:image/png;base64,...", x: 1, y: 1.5, w: 8, h: 4.5 });
+
+// Slide with table
+const tableSlide = pres.addSlide();
+tableSlide.addText("Data Overview", { x: 0.5, y: 0.3, w: 9, h: 0.8, fontSize: 28, bold: true });
+tableSlide.addTable(
+  [
+    [{ text: "Metric", options: { bold: true, fill: { color: "2563eb" }, color: "ffffff" } },
+     { text: "Value", options: { bold: true, fill: { color: "2563eb" }, color: "ffffff" } }],
+    ["Users", "10,542"],
+    ["Revenue", "$52,300"],
+    ["Growth", "+23%"],
+  ],
+  { x: 1, y: 1.5, w: 8, colW: [4, 4], border: { type: "solid", pt: 1, color: "cccccc" } }
+);
+
+// Write file
+await pres.writeFile({ fileName: "output.pptx" });
+// Or get buffer: const buffer = await pres.write({ outputType: "nodebuffer" });
+```
+
+## Reading Existing .pptx
+
+Use `adm-zip` to extract XML content from existing presentations:
+
+```typescript
+import AdmZip from "adm-zip";
+
+const zip = new AdmZip("input.pptx");
+const slideEntries = zip.getEntries().filter(e => e.entryName.startsWith("ppt/slides/slide"));
+for (const entry of slideEntries) {
+  const xml = entry.getData().toString("utf-8");
+  // Parse XML to extract text content
+}
+```
+
+## Slide Design Rules
+
+- Maximum 6 bullet points per slide
+- Maximum 8 words per bullet
+- One key idea per slide
+- Consistent fonts and colors throughout
+- Include slide numbers
+- Add speaker notes for every content slide
+- Minimum structure: title, agenda, content slides, summary
+- High-contrast text (dark on light or light on dark)
+- Always use 16:9 layout unless specified otherwise
+
+## Rules
+
+- Use `pptxgenjs` for creation (pure JS, Bun-compatible)
+- Always include speaker notes
+- Always use 16:9 layout
+- Test output opens in PowerPoint or LibreOffice Impress
+- All packages are MIT licensed, no Python required

package/skills/builtin/prisma-orm/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: prisma-orm
+description: "Use this skill when working with Prisma ORM. Triggers: 'Prisma', 'prisma schema', 'prisma migrate', 'prisma client', or any Prisma-related request. Always fetch Context7 docs first."
+license: MIT
+---
+
+# Prisma ORM
+
+## Before You Start
+
+**Context7:** ALWAYS fetch current Prisma docs before generating schema or queries.
+
+## Schema Pattern
+
+```prisma
+model User {
+  id        String   @id @default(uuid())
+  email     String   @unique
+  name      String
+  posts     Post[]
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  @@index([email])
+}
+
+model Post {
+  id        String   @id @default(uuid())
+  title     String
+  content   String
+  published Boolean  @default(false)
+  author    User     @relation(fields: [authorId], references: [id], onDelete: Cascade)
+  authorId  String
+  createdAt DateTime @default(now())
+
+  @@index([authorId])
+  @@index([published, createdAt(sort: Desc)])
+}
+```
+
+## Rules
+
+- Always add @@index for foreign keys and commonly queried fields
+- Use @updatedAt for automatic timestamp management
+- Prefer uuid() over autoincrement() for distributed systems
+- Always run `prisma generate` after schema changes
+- Always run `prisma migrate dev` to create migration files
+- Fetch Context7 docs for current Prisma Client API before writing queries

package/skills/builtin/rag-database-routing/SKILL.md

@@ -0,0 +1,38 @@
+# RAG Database Routing
+## Pattern
+When multiple knowledge bases exist, classify the query before retrieving:
+
+```
+Query → Classifier → Route to correct KB → Retrieve → Generate
+```
+
+## Routing Logic
+- **Technical docs** → code documentation vector store
+- **Business/policy** → internal documents store
+- **Product info** → product catalog store
+- **General/current** → web search
+- **Ambiguous** → query multiple stores, merge results with RRF
+
+## Implementation
+```typescript
+function routeQuery(query: string): string[] {
+  // Classify intent
+  const intent = classifyIntent(query); // lightweight LLM or keyword matching
+
+  // Map to knowledge bases
+  const routes: Record<string, string[]> = {
+    technical: ["code_docs"],
+    business: ["internal_docs"],
+    product: ["product_catalog"],
+    general: ["web_search"],
+    ambiguous: ["code_docs", "internal_docs", "web_search"],
+  };
+
+  return routes[intent] || routes.ambiguous;
+}
+```
+
+## Rules
+- Classify before retrieving (don't search all stores for every query)
+- "Ambiguous" should query multiple stores, not guess
+- Log routing decisions for accuracy monitoring.

package/skills/builtin/rapid-prototyping/SKILL.md

@@ -0,0 +1,152 @@
+---
+name: rapid-prototyping
+description: "Use this skill when the user wants a quick proof-of-concept, MVP, working demo, or prototype built fast. Triggers: 'quick prototype', 'MVP', 'proof of concept', 'demo', 'just get it working', 'rough draft', 'hack something together', 'spike', or when speed matters more than polish. Prioritizes working code over perfect architecture."
+license: MIT
+---
+
+# Rapid Prototyping
+
+## What This Skill Does
+
+Build working prototypes fast. Ship a functional demo in minimum time. Cut every corner that doesn't affect whether the thing works. Perfect code comes later.
+
+## Mindset
+
+Speed over polish. Working over elegant. Done over perfect.
+
+But never skip: input validation, error handling that tells the user what went wrong, and basic security (no hardcoded secrets, no SQL injection).
+
+## Decision Framework
+
+| Question | Prototype Answer |
+|----------|-----------------|
+| Database? | SQLite file or JSON file. No Postgres setup. |
+| Auth? | Simple token or session. No OAuth flows. |
+| Frontend? | Single HTML file or minimal React. No design system. |
+| Styling? | Tailwind CDN or inline styles. No custom CSS. |
+| Testing? | Manual testing. No test suite. |
+| Deployment? | Local only. Or single `docker run` command. |
+| Error handling? | Try/catch with console.log. User sees "Something went wrong." |
+| Types? | Use TypeScript but `as any` is acceptable for prototypes |
+
+## Fastest Stacks
+
+### Web App (under 2 hours)
+```
+Bun + Hono (server) + single HTML file (client) + SQLite (data)
+```
+
+### API Only (under 1 hour)
+```
+Bun + Hono + JSON file storage
+```
+
+### Interactive Tool (under 30 minutes)
+```
+Single HTML file with vanilla JS (use web-artifacts-builder skill)
+```
+
+### Full App with Auth (under 4 hours)
+```
+Next.js + SQLite + simple JWT + Tailwind CDN
+```
+
+## Patterns
+
+### JSON File Database (zero setup)
+```typescript
+import { readFileSync, writeFileSync, existsSync } from "fs";
+
+const DB_PATH = "./data.json";
+
+function readDB(): any {
+  if (!existsSync(DB_PATH)) return { items: [] };
+  return JSON.parse(readFileSync(DB_PATH, "utf-8"));
+}
+
+function writeDB(data: any) {
+  writeFileSync(DB_PATH, JSON.stringify(data, null, 2));
+}
+```
+
+### Quick API Server (Hono + Bun)
+```typescript
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+
+const app = new Hono();
+app.use("*", cors());
+
+app.get("/api/items", (c) => {
+  const db = readDB();
+  return c.json(db.items);
+});
+
+app.post("/api/items", async (c) => {
+  const body = await c.req.json();
+  const db = readDB();
+  const item = { id: crypto.randomUUID(), ...body, createdAt: new Date() };
+  db.items.push(item);
+  writeDB(db);
+  return c.json(item, 201);
+});
+
+export default { port: 3000, fetch: app.fetch };
+```
+
+### Inline Frontend (embed in server response)
+```typescript
+app.get("/", (c) => {
+  return c.html(`
+    <!DOCTYPE html>
+    <html>
+    <head>
+      <script src="https://cdn.tailwindcss.com"></script>
+    </head>
+    <body class="p-8 max-w-2xl mx-auto">
+      <h1 class="text-2xl font-bold mb-4">My Prototype</h1>
+      <div id="app"></div>
+      <script>
+        // Vanilla JS UI here
+      </script>
+    </body>
+    </html>
+  `);
+});
+```
+
+## Rules
+
+- Get to "it works" as fast as possible
+- Ask clarifying questions ONLY if you literally cannot proceed without the answer
+- Use the simplest tool that solves the problem
+- Hardcode configuration values (but never secrets)
+- Skip abstractions. Direct function calls over dependency injection.
+- One file is better than five files for a prototype
+- README can be 3 lines: what it does, how to run it, what's missing
+- When the prototype works, tell the user what you'd change for production
+
+## When to Stop Prototyping
+
+The prototype is done when the user can interact with the core feature. Stop and show them. Let them direct what happens next. Do not refactor, add tests, or polish without being asked.
+
+## Verification
+
+1. The thing runs
+2. The core feature works when you click/type/submit
+3. Errors don't crash the process (they show a message)
+4. The user can run it with one command from the README
+
+## Graduating to Production
+
+When the user wants to turn the prototype into a real project, switch to the appropriate skill:
+- **fullstack-project** for complete application scaffolding
+- **backend-development** for proper API architecture
+- **database-design** for real schema design
+- **docker-deployment** for containerization
+
+## Efficient Tool Batching (Lovable pattern)
+
+Combine multiple independent operations into a single turn. Create all files in one batch rather than asking for confirmation between each.
+
+Ambiguous: discuss first. Clear: build immediately.