@rubix0270/arboris 1.0.2 → 1.0.4

package/prisma/skills/network-interface-health/SKILL.md

@@ -1,153 +0,0 @@
----
-name: network-interface-health
-description: Diagnose interface errors, drops, CRCs, duplex mismatches, flapping, speed negotiation issues, and counter trends on routers, switches, and Linux hosts.
-metadata:
-  origin: community
----
-
-# Network Interface Health
-
-Use this skill when a network symptom might be caused by a physical link, switch
-port, cable, transceiver, duplex setting, or congested interface.
-
-## When to Use
-
-- A host or VLAN has packet loss, latency spikes, or intermittent reachability.
-- A switch or router interface shows CRCs, runts, giants, drops, resets, or flaps.
-- You need to compare both ends of a link before replacing hardware.
-- A change window needs before/after interface counter evidence.
-- Monitoring reports rising `ifInErrors`, `ifOutErrors`, or `ifOutDiscards`.
-
-## How It Works
-
-Interface counters are evidence, but the trend matters more than the absolute
-number. Capture a baseline, wait a measurement interval, capture again, then
-compare increments.
-
-```text
-show interfaces <interface>
-show interfaces <interface> status
-show logging | include <interface>|changed state|line protocol
-```
-
-On Linux hosts:
-
-```text
-ip -s link show <interface>
-ethtool <interface>
-ethtool -S <interface>
-```
-
-## Counter Reference
-
-| Counter | Meaning | Common cause |
-| --- | --- | --- |
-| CRC | Received frame checksum failed | Bad cable, dirty fiber, bad optic, duplex mismatch |
-| input errors | Aggregate receive-side errors | Check sub-counters before concluding |
-| runts | Frames below minimum Ethernet size | Duplex mismatch, collision domain, faulty NIC |
-| giants | Frames larger than expected MTU | MTU mismatch or jumbo-frame boundary |
-| input drops | Device could not accept inbound packets | Burst, oversubscription, CPU path, queue pressure |
-| output drops | Egress queue discarded packets | Congestion, QoS policy, undersized uplink |
-| resets | Interface hardware reset | Flapping, keepalive, driver, optic, power |
-| collisions | Ethernet collision counter | Half duplex or negotiation mismatch |
-
-## Diagnosis Flow
-
-### CRCs Or Input Errors
-
-1. Confirm counters are incrementing, not just historical.
-2. Check both ends of the link. Receive-side errors usually point to the signal
-   arriving on that side, not necessarily the port reporting the error.
-3. Replace patch cable or clean/replace fiber and optics.
-4. Confirm speed/duplex settings match on both sides.
-5. Check logs for flap events around the same timestamp.
-
-### Drops
-
-1. Separate input drops from output drops.
-2. Compare interface rate against capacity.
-3. Check QoS policy, queue counters, and whether the link is an oversubscribed
-   uplink.
-4. Treat queue tuning as secondary. First prove whether the link is congested.
-
-### Duplex And Speed
-
-Prefer auto-negotiation on modern Ethernet links when both sides support it. If
-one side must be fixed, configure both sides explicitly and document why. Never
-mix fixed speed/duplex on one side with auto on the other.
-
-```text
-show interfaces <interface> | include duplex|speed
-```
-
-## Safe Parser Example
-
-Slice each interface block from one header to the next. Do not use an arbitrary
-character window; large interface blocks can cause counters to be missed or
-assigned to the wrong port.
-
-```python
-import re
-from typing import Any
-
-HEADER_RE = re.compile(
-    r"^(?P<name>\S+) is (?P<status>(?:administratively )?down|up), "
-    r"line protocol is (?P<protocol>up|down)",
-    re.I | re.M,
-)
-ERROR_RE = re.compile(r"(?P<input>\d+) input errors, (?P<crc>\d+) CRC", re.I)
-DROP_RE = re.compile(r"(?P<output>\d+) output errors", re.I)
-DUPLEX_RE = re.compile(r"(?P<duplex>Full|Half|Auto)-duplex,\s+(?P<speed>[^,]+)", re.I)
-
-def parse_show_interfaces(raw: str) -> list[dict[str, Any]]:
-    headers = list(HEADER_RE.finditer(raw))
-    interfaces = []
-    for index, header in enumerate(headers):
-        end = headers[index + 1].start() if index + 1 < len(headers) else len(raw)
-        block = raw[header.start():end]
-        errors = ERROR_RE.search(block)
-        drops = DROP_RE.search(block)
-        duplex = DUPLEX_RE.search(block)
-        interfaces.append({
-            "name": header.group("name"),
-            "status": header.group("status"),
-            "protocol": header.group("protocol"),
-            "duplex": duplex.group("duplex") if duplex else "unknown",
-            "speed": duplex.group("speed").strip() if duplex else "unknown",
-            "input_errors": int(errors.group("input")) if errors else 0,
-            "crc_errors": int(errors.group("crc")) if errors else 0,
-            "output_errors": int(drops.group("output")) if drops else 0,
-        })
-    return interfaces
-```
-
-## Examples
-
-### CRCs On One Switch Port
-
-1. Capture counters on the local port.
-2. Capture counters on the connected remote port.
-3. Replace the cable or optic before changing routing or firewall rules.
-4. Clear counters only after recording the baseline.
-5. Recheck after a fixed interval.
-
-### Internet Slow But LAN Is Fine
-
-1. Check WAN interface drops/errors.
-2. Check LAN uplink utilization and output drops.
-3. Check gateway CPU if the WAN link is clean but throughput is still low.
-4. Compare wired and wireless tests before blaming upstream service.
-
-## Anti-Patterns
-
-- Clearing counters before saving a baseline.
-- Looking at only one side of a link.
-- Assuming all historical CRCs are active problems without a time window.
-- Mixing auto-negotiation on one side with fixed speed/duplex on the other.
-- Treating output drops as a cable problem before checking congestion.
-
-## See Also
-
-- Agent: `network-troubleshooter`
-- Skill: `network-config-validation`
-- Skill: `homelab-network-setup`

package/prisma/skills/nextjs-turbopack/SKILL.md

@@ -1,58 +0,0 @@
----
-name: nextjs-turbopack
-description: Next.js 16+ and Turbopack — incremental bundling, FS caching, dev speed, and when to use Turbopack vs webpack.
-metadata:
-  origin: ECC
----
-
-# Next.js and Turbopack
-
-Next.js 16+ uses Turbopack by default for local development: an incremental bundler written in Rust that significantly speeds up dev startup and hot updates.
-
-## When to Use
-
-- **Turbopack (default dev)**: Use for day-to-day development. Faster cold start and HMR, especially in large apps.
-- **Webpack (legacy dev)**: Use only if you hit a Turbopack bug or rely on a webpack-only plugin in dev. Disable with `--webpack` (or `--no-turbopack` depending on your Next.js version; check the docs for your release).
-- **Production**: Production build behavior (`next build`) may use Turbopack or webpack depending on Next.js version; check the official Next.js docs for your version.
-
-Use when: developing or debugging Next.js 16+ apps, diagnosing slow dev startup or HMR, or optimizing production bundles.
-
-## How It Works
-
-- **Turbopack**: Incremental bundler for Next.js dev. Uses file-system caching so restarts are much faster (e.g. 5–14x on large projects).
-- **Default in dev**: From Next.js 16, `next dev` runs with Turbopack unless disabled.
-- **File-system caching**: Restarts reuse previous work; cache is typically under `.next`; no extra config needed for basic use.
-- **Bundle Analyzer (Next.js 16.1+)**: Experimental Bundle Analyzer to inspect output and find heavy dependencies; enable via config or experimental flag (see Next.js docs for your version).
-
-## Examples
-
-### Commands
-
-```bash
-next dev
-next build
-next start
-```
-
-### Usage
-
-Run `next dev` for local development with Turbopack. Use the Bundle Analyzer (see Next.js docs) to optimize code-splitting and trim large dependencies. Prefer App Router and server components where possible.
-
-## Middleware File Naming
-
-Next.js 16 introduced `proxy.ts` as the middleware filename, replacing the older `middleware.ts` convention:
-
-- **Next.js 16+**: use `proxy.ts` at the project root
-- **Pre-Next.js 16**: use `middleware.ts` at the project root
-
-The filename change is tied to the **Next.js version**, not to which bundler (Turbopack or webpack) is in use. Always check the official docs for the version you are reviewing.
-
-**Do not flag `proxy.ts` as a misnamed or missing middleware file in Next.js 16 projects.** The file is correct and intentional. Suggesting a rename to `middleware.ts` will break middleware execution.
-
-Reference: [Next.js proxy docs](https://nextjs.org/docs/app/getting-started/proxy)
-
-## Best Practices
-
-- Stay on a recent Next.js 16.x for stable Turbopack and caching behavior.
-- If dev is slow, ensure you're on Turbopack (default) and that the cache isn't being cleared unnecessarily.
-- For production bundle size issues, use the official Next.js bundle analysis tooling for your version.

package/prisma/skills/nodejs-keccak256/SKILL.md

@@ -1,103 +0,0 @@
----
-name: nodejs-keccak256
-description: Prevent Ethereum hashing bugs in JavaScript and TypeScript. Node's sha3-256 is NIST SHA3, not Ethereum Keccak-256, and silently breaks selectors, signatures, storage slots, and address derivation.
-metadata:
-  origin: ECC direct-port adaptation
-version: "1.0.0"
----
-
-# Node.js Keccak-256
-
-Ethereum uses Keccak-256, not the NIST-standardized SHA3 variant exposed by Node's `crypto.createHash('sha3-256')`.
-
-## When to Use
-
-- Computing Ethereum function selectors or event topics
-- Building EIP-712, signature, Merkle, or storage-slot helpers in JS/TS
-- Reviewing any code that hashes Ethereum data with Node crypto directly
-
-## How It Works
-
-The two algorithms produce different outputs for the same input, and Node will not warn you.
-
-```javascript
-import crypto from 'crypto';
-import { keccak256, toUtf8Bytes } from 'ethers';
-
-const data = 'hello';
-const nistSha3 = crypto.createHash('sha3-256').update(data).digest('hex');
-const keccak = keccak256(toUtf8Bytes(data)).slice(2);
-
-console.log(nistSha3 === keccak); // false
-```
-
-## Examples
-
-### ethers v6
-
-```typescript
-import { keccak256, toUtf8Bytes, solidityPackedKeccak256, id } from 'ethers';
-
-const hash = keccak256(new Uint8Array([0x01, 0x02]));
-const hash2 = keccak256(toUtf8Bytes('hello'));
-const topic = id('Transfer(address,address,uint256)');
-const packed = solidityPackedKeccak256(
-  ['address', 'uint256'],
-  ['0x742d35Cc6634C0532925a3b8D4C9B569890FaC1c', 100n],
-);
-```
-
-### viem
-
-```typescript
-import { keccak256, toBytes } from 'viem';
-
-const hash = keccak256(toBytes('hello'));
-```
-
-### web3.js
-
-```javascript
-const hash = web3.utils.keccak256('hello');
-const packed = web3.utils.soliditySha3(
-  { type: 'address', value: '0x742d35Cc6634C0532925a3b8D4C9B569890FaC1c' },
-  { type: 'uint256', value: '100' },
-);
-```
-
-### Common patterns
-
-```typescript
-import { id, keccak256, AbiCoder } from 'ethers';
-
-const selector = id('transfer(address,uint256)').slice(0, 10);
-const typeHash = keccak256(toUtf8Bytes('Transfer(address from,address to,uint256 value)'));
-
-function getMappingSlot(key: string, mappingSlot: number): string {
-  return keccak256(
-    AbiCoder.defaultAbiCoder().encode(['address', 'uint256'], [key, mappingSlot]),
-  );
-}
-```
-
-### Address from public key
-
-```typescript
-import { keccak256 } from 'ethers';
-
-function pubkeyToAddress(pubkeyBytes: Uint8Array): string {
-  const hash = keccak256(pubkeyBytes.slice(1));
-  return '0x' + hash.slice(-40);
-}
-```
-
-### Audit your codebase
-
-```bash
-grep -rn "createHash.*sha3" --include="*.ts" --include="*.js" --exclude-dir=node_modules .
-grep -rn "keccak256" --include="*.ts" --include="*.js" . | grep -v node_modules
-```
-
-## Rule
-
-For Ethereum contexts, never use `crypto.createHash('sha3-256')`. Use Keccak-aware helpers from `ethers`, `viem`, `web3`, or another explicit Keccak implementation.

package/prisma/skills/nutrient-document-processing/SKILL.md

@@ -1,168 +0,0 @@
----
-name: nutrient-document-processing
-description: Process, convert, OCR, extract, redact, sign, and fill documents using the Nutrient DWS API. Works with PDFs, DOCX, XLSX, PPTX, HTML, and images.
-metadata:
-  origin: ECC
----
-
-# Nutrient Document Processing
-
-> **Note:** This skill integrates with the Nutrient commercial API. Review their terms before use.
-
-Process documents with the [Nutrient DWS Processor API](https://www.nutrient.io/api/). Convert formats, extract text and tables, OCR scanned documents, redact PII, add watermarks, digitally sign, and fill PDF forms.
-
-## Setup
-
-Get a free API key at **[nutrient.io](https://dashboard.nutrient.io/sign_up/?product=processor)**
-
-```bash
-export NUTRIENT_API_KEY="pdf_live_..."
-```
-
-All requests go to `https://api.nutrient.io/build` as multipart POST with an `instructions` JSON field.
-
-## Operations
-
-### Convert Documents
-
-```bash
-# DOCX to PDF
-curl -X POST https://api.nutrient.io/build \
-  -H "Authorization: Bearer $NUTRIENT_API_KEY" \
-  -F "document.docx=@document.docx" \
-  -F 'instructions={"parts":[{"file":"document.docx"}]}' \
-  -o output.pdf
-
-# PDF to DOCX
-curl -X POST https://api.nutrient.io/build \
-  -H "Authorization: Bearer $NUTRIENT_API_KEY" \
-  -F "document.pdf=@document.pdf" \
-  -F 'instructions={"parts":[{"file":"document.pdf"}],"output":{"type":"docx"}}' \
-  -o output.docx
-
-# HTML to PDF
-curl -X POST https://api.nutrient.io/build \
-  -H "Authorization: Bearer $NUTRIENT_API_KEY" \
-  -F "index.html=@index.html" \
-  -F 'instructions={"parts":[{"html":"index.html"}]}' \
-  -o output.pdf
-```
-
-Supported inputs: PDF, DOCX, XLSX, PPTX, DOC, XLS, PPT, PPS, PPSX, ODT, RTF, HTML, JPG, PNG, TIFF, HEIC, GIF, WebP, SVG, TGA, EPS.
-
-### Extract Text and Data
-
-```bash
-# Extract plain text
-curl -X POST https://api.nutrient.io/build \
-  -H "Authorization: Bearer $NUTRIENT_API_KEY" \
-  -F "document.pdf=@document.pdf" \
-  -F 'instructions={"parts":[{"file":"document.pdf"}],"output":{"type":"text"}}' \
-  -o output.txt
-
-# Extract tables as Excel
-curl -X POST https://api.nutrient.io/build \
-  -H "Authorization: Bearer $NUTRIENT_API_KEY" \
-  -F "document.pdf=@document.pdf" \
-  -F 'instructions={"parts":[{"file":"document.pdf"}],"output":{"type":"xlsx"}}' \
-  -o tables.xlsx
-```
-
-### OCR Scanned Documents
-
-```bash
-# OCR to searchable PDF (supports 100+ languages)
-curl -X POST https://api.nutrient.io/build \
-  -H "Authorization: Bearer $NUTRIENT_API_KEY" \
-  -F "scanned.pdf=@scanned.pdf" \
-  -F 'instructions={"parts":[{"file":"scanned.pdf"}],"actions":[{"type":"ocr","language":"english"}]}' \
-  -o searchable.pdf
-```
-
-Languages: Supports 100+ languages via ISO 639-2 codes (e.g., `eng`, `deu`, `fra`, `spa`, `jpn`, `kor`, `chi_sim`, `chi_tra`, `ara`, `hin`, `rus`). Full language names like `english` or `german` also work. See the [complete OCR language table](https://www.nutrient.io/guides/document-engine/ocr/language-support/) for all supported codes.
-
-### Redact Sensitive Information
-
-```bash
-# Pattern-based (SSN, email)
-curl -X POST https://api.nutrient.io/build \
-  -H "Authorization: Bearer $NUTRIENT_API_KEY" \
-  -F "document.pdf=@document.pdf" \
-  -F 'instructions={"parts":[{"file":"document.pdf"}],"actions":[{"type":"redaction","strategy":"preset","strategyOptions":{"preset":"social-security-number"}},{"type":"redaction","strategy":"preset","strategyOptions":{"preset":"email-address"}}]}' \
-  -o redacted.pdf
-
-# Regex-based
-curl -X POST https://api.nutrient.io/build \
-  -H "Authorization: Bearer $NUTRIENT_API_KEY" \
-  -F "document.pdf=@document.pdf" \
-  -F 'instructions={"parts":[{"file":"document.pdf"}],"actions":[{"type":"redaction","strategy":"regex","strategyOptions":{"regex":"\\b[A-Z]{2}\\d{6}\\b"}}]}' \
-  -o redacted.pdf
-```
-
-Presets: `social-security-number`, `email-address`, `credit-card-number`, `international-phone-number`, `north-american-phone-number`, `date`, `time`, `url`, `ipv4`, `ipv6`, `mac-address`, `us-zip-code`, `vin`.
-
-### Add Watermarks
-
-```bash
-curl -X POST https://api.nutrient.io/build \
-  -H "Authorization: Bearer $NUTRIENT_API_KEY" \
-  -F "document.pdf=@document.pdf" \
-  -F 'instructions={"parts":[{"file":"document.pdf"}],"actions":[{"type":"watermark","text":"CONFIDENTIAL","fontSize":72,"opacity":0.3,"rotation":-45}]}' \
-  -o watermarked.pdf
-```
-
-### Digital Signatures
-
-```bash
-# Self-signed CMS signature
-curl -X POST https://api.nutrient.io/build \
-  -H "Authorization: Bearer $NUTRIENT_API_KEY" \
-  -F "document.pdf=@document.pdf" \
-  -F 'instructions={"parts":[{"file":"document.pdf"}],"actions":[{"type":"sign","signatureType":"cms"}]}' \
-  -o signed.pdf
-```
-
-### Fill PDF Forms
-
-```bash
-curl -X POST https://api.nutrient.io/build \
-  -H "Authorization: Bearer $NUTRIENT_API_KEY" \
-  -F "form.pdf=@form.pdf" \
-  -F 'instructions={"parts":[{"file":"form.pdf"}],"actions":[{"type":"fillForm","formFields":{"name":"Jane Smith","email":"jane@example.com","date":"2026-02-06"}}]}' \
-  -o filled.pdf
-```
-
-## MCP Server (Alternative)
-
-For native tool integration, use the MCP server instead of curl:
-
-```json
-{
-  "mcpServers": {
-    "nutrient-dws": {
-      "command": "npx",
-      "args": ["-y", "@nutrient-sdk/dws-mcp-server"],
-      "env": {
-        "NUTRIENT_DWS_API_KEY": "YOUR_API_KEY",
-        "SANDBOX_PATH": "/path/to/working/directory"
-      }
-    }
-  }
-}
-```
-
-## When to Use
-
-- Converting documents between formats (PDF, DOCX, XLSX, PPTX, HTML, images)
-- Extracting text, tables, or key-value pairs from PDFs
-- OCR on scanned documents or images
-- Redacting PII before sharing documents
-- Adding watermarks to drafts or confidential documents
-- Digitally signing contracts or agreements
-- Filling PDF forms programmatically
-
-## Links
-
-- [API Playground](https://dashboard.nutrient.io/processor-api/playground/)
-- [Full API Docs](https://www.nutrient.io/guides/dws-processor/)
-- [npm MCP Server](https://www.npmjs.com/package/@nutrient-sdk/dws-mcp-server)

package/prisma/skills/nuxt4-patterns/SKILL.md

@@ -1,101 +0,0 @@
----
-name: nuxt4-patterns
-description: Nuxt 4 app patterns for hydration safety, performance, route rules, lazy loading, and SSR-safe data fetching with useFetch and useAsyncData.
-metadata:
-  origin: ECC
----
-
-# Nuxt 4 Patterns
-
-Use when building or debugging Nuxt 4 apps with SSR, hybrid rendering, route rules, or page-level data fetching.
-
-## When to Activate
-
-- Hydration mismatches between server HTML and client state
-- Route-level rendering decisions such as prerender, SWR, ISR, or client-only sections
-- Performance work around lazy loading, lazy hydration, or payload size
-- Page or component data fetching with `useFetch`, `useAsyncData`, or `$fetch`
-- Nuxt routing issues tied to route params, middleware, or SSR/client differences
-
-## Hydration Safety
-
-- Keep the first render deterministic. Do not put `Date.now()`, `Math.random()`, browser-only APIs, or storage reads directly into SSR-rendered template state.
-- Move browser-only logic behind `onMounted()`, `import.meta.client`, `ClientOnly`, or a `.client.vue` component when the server cannot produce the same markup.
-- Use Nuxt's `useRoute()` composable, not the one from `vue-router`.
-- Do not use `route.fullPath` to drive SSR-rendered markup. URL fragments are client-only, which can create hydration mismatches.
-- Treat `ssr: false` as an escape hatch for truly browser-only areas, not a default fix for mismatches.
-
-## Data Fetching
-
-- Prefer `await useFetch()` for SSR-safe API reads in pages and components. It forwards server-fetched data into the Nuxt payload and avoids a second fetch on hydration.
-- Use `useAsyncData()` when the fetcher is not a simple `$fetch()` call, when you need a custom key, or when you are composing multiple async sources.
-- Give `useAsyncData()` a stable key for cache reuse and predictable refresh behavior.
-- Keep `useAsyncData()` handlers side-effect free. They can run during SSR and hydration.
-- Use `$fetch()` for user-triggered writes or client-only actions, not top-level page data that should be hydrated from SSR.
-- Use `lazy: true`, `useLazyFetch()`, or `useLazyAsyncData()` for non-critical data that should not block navigation. Handle `status === 'pending'` in the UI.
-- Use `server: false` only for data that is not needed for SEO or the first paint.
-- Trim payload size with `pick` and prefer shallower payloads when deep reactivity is unnecessary.
-
-```ts
-const route = useRoute()
-
-const { data: article, status, error, refresh } = await useAsyncData(
-  () => `article:${route.params.slug}`,
-  () => $fetch(`/api/articles/${route.params.slug}`),
-)
-
-const { data: comments } = await useFetch(`/api/articles/${route.params.slug}/comments`, {
-  lazy: true,
-  server: false,
-})
-```
-
-## Route Rules
-
-Prefer `routeRules` in `nuxt.config.ts` for rendering and caching strategy:
-
-```ts
-export default defineNuxtConfig({
-  routeRules: {
-    '/': { prerender: true },
-    '/products/**': { swr: 3600 },
-    '/blog/**': { isr: true },
-    '/admin/**': { ssr: false },
-    '/api/**': { cache: { maxAge: 60 * 60 } },
-  },
-})
-```
-
-- `prerender`: static HTML at build time
-- `swr`: serve cached content and revalidate in the background
-- `isr`: incremental static regeneration on supported platforms
-- `ssr: false`: client-rendered route
-- `cache` or `redirect`: Nitro-level response behavior
-
-Pick route rules per route group, not globally. Marketing pages, catalogs, dashboards, and APIs usually need different strategies.
-
-## Lazy Loading and Performance
-
-- Nuxt already code-splits pages by route. Keep route boundaries meaningful before micro-optimizing component splits.
-- Use the `Lazy` prefix to dynamically import non-critical components.
-- Conditionally render lazy components with `v-if` so the chunk is not loaded until the UI actually needs it.
-- Use lazy hydration for below-the-fold or non-critical interactive UI.
-
-```vue
-<template>
-  <LazyRecommendations v-if="showRecommendations" />
-  <LazyProductGallery hydrate-on-visible />
-</template>
-```
-
-- For custom strategies, use `defineLazyHydrationComponent()` with a visibility or idle strategy.
-- Nuxt lazy hydration works on single-file components. Passing new props to a lazily hydrated component will trigger hydration immediately.
-- Use `NuxtLink` for internal navigation so Nuxt can prefetch route components and generated payloads.
-
-## Review Checklist
-
-- First SSR render and hydrated client render produce the same markup
-- Page data uses `useFetch` or `useAsyncData`, not top-level `$fetch`
-- Non-critical data is lazy and has explicit loading UI
-- Route rules match the page's SEO and freshness requirements
-- Heavy interactive islands are lazy-loaded or lazily hydrated