@diottodev/runic 1.0.0 → 1.1.0

package/engineering-team/playwright-pro/skills/testrail/SKILL.md

@@ -0,0 +1,129 @@
+---
+name: "testrail"
+description: >-
+  Sync tests with TestRail. Use when user mentions "testrail", "test management",
+  "test cases", "test run", "sync test cases", "push results to testrail",
+  or "import from testrail".
+---
+
+# TestRail Integration
+
+Bidirectional sync between Playwright tests and TestRail test management.
+
+## Prerequisites
+
+Environment variables must be set:
+- `TESTRAIL_URL` — e.g., `https://your-instance.testrail.io`
+- `TESTRAIL_USER` — your email
+- `TESTRAIL_API_KEY` — API key from TestRail
+
+If not set, inform the user how to configure them and stop.
+
+## Capabilities
+
+### 1. Import Test Cases → Generate Playwright Tests
+
+```
+/pw:testrail import --project <id> --suite <id>
+```
+
+Steps:
+1. Call `testrail_get_cases` MCP tool to fetch test cases
+2. For each test case:
+   - Read title, preconditions, steps, expected results
+   - Map to a Playwright test using appropriate template
+   - Include TestRail case ID as test annotation: `test.info().annotations.push({ type: 'testrail', description: 'C12345' })`
+3. Generate test files grouped by section
+4. Report: X cases imported, Y tests generated
+
+### 2. Push Test Results → TestRail
+
+```
+/pw:testrail push --run <id>
+```
+
+Steps:
+1. Run Playwright tests with JSON reporter:
+   ```bash
+   npx playwright test --reporter=json > test-results.json
+   ```
+2. Parse results: map each test to its TestRail case ID (from annotations)
+3. Call `testrail_add_result` MCP tool for each test:
+   - Pass → status_id: 1
+   - Fail → status_id: 5, include error message
+   - Skip → status_id: 2
+4. Report: X results pushed, Y passed, Z failed
+
+### 3. Create Test Run
+
+```
+/pw:testrail run --project <id> --name "Sprint 42 Regression"
+```
+
+Steps:
+1. Call `testrail_add_run` MCP tool
+2. Include all test case IDs found in Playwright test annotations
+3. Return run ID for result pushing
+
+### 4. Sync Status
+
+```
+/pw:testrail status --project <id>
+```
+
+Steps:
+1. Fetch test cases from TestRail
+2. Scan local Playwright tests for TestRail annotations
+3. Report coverage:
+   ```
+   TestRail cases: 150
+   Playwright tests with TestRail IDs: 120
+   Unlinked TestRail cases: 30
+   Playwright tests without TestRail IDs: 15
+   ```
+
+### 5. Update Test Cases in TestRail
+
+```
+/pw:testrail update --case <id>
+```
+
+Steps:
+1. Read the Playwright test for this case ID
+2. Extract steps and expected results from test code
+3. Call `testrail_update_case` MCP tool to update steps
+
+## MCP Tools Used
+
+| Tool | When |
+|---|---|
+| `testrail_get_projects` | List available projects |
+| `testrail_get_suites` | List suites in project |
+| `testrail_get_cases` | Read test cases |
+| `testrail_add_case` | Create new test case |
+| `testrail_update_case` | Update existing case |
+| `testrail_add_run` | Create test run |
+| `testrail_add_result` | Push individual result |
+| `testrail_get_results` | Read historical results |
+
+## Test Annotation Format
+
+All Playwright tests linked to TestRail include:
+
+```typescript
+test('should login successfully', async ({ page }) => {
+  test.info().annotations.push({
+    type: 'testrail',
+    description: 'C12345',
+  });
+  // ... test code
+});
+```
+
+This annotation is the bridge between Playwright and TestRail.
+
+## Output
+
+- Operation summary with counts
+- Any errors or unmatched cases
+- Link to TestRail run/results

package/engineering-team/self-improving-agent/.claude-plugin/plugin.json

@@ -0,0 +1,15 @@
+{
+  "name": "si",
+  "version": "2.9.0",
+  "description": "Self-Improving Agent: curate auto-memory, promote learnings to CLAUDE.md and rules, extract proven patterns into reusable skills. Provides /si:review, /si:promote, /si:extract, /si:status, and /si:remember slash commands.",
+  "author": {
+    "name": "Alireza Rezvani",
+    "url": "https://alirezarezvani.com"
+  },
+  "repository": "https://github.com/alirezarezvani/claude-skills",
+  "license": "MIT",
+  "skills": [
+    "./skills"
+  ],
+  "homepage": "https://github.com/alirezarezvani/claude-skills/tree/main/engineering-team/self-improving-agent"
+}

package/engineering-team/self-improving-agent/CLAUDE.md

@@ -0,0 +1,84 @@
+# Self-Improving Agent — Claude Code Instructions
+
+This plugin helps you curate Claude Code's auto-memory into durable project knowledge.
+
+## Commands
+
+Use the `/si:` namespace for all commands:
+
+- `/si:review` — Analyze auto-memory health and find promotion candidates
+- `/si:promote <pattern>` — Graduate a learning to CLAUDE.md or `.claude/rules/`
+- `/si:extract <pattern>` — Create a reusable skill from a proven pattern
+- `/si:status` — Quick memory health dashboard
+- `/si:remember <knowledge>` — Explicitly save something to auto-memory
+
+## How auto-memory works
+
+Claude Code maintains `~/.claude/projects/<project-path>/memory/MEMORY.md` automatically. The first 200 lines load into every session. When it grows too large, Claude moves details into topic files like `debugging.md` or `patterns.md`.
+
+This plugin reads that directory — it never creates its own storage.
+
+## When to use each command
+
+### After completing a feature or debugging session
+```
+/si:review
+```
+Check if anything Claude learned should become a permanent rule.
+
+### When a pattern keeps coming up
+```
+/si:promote "Always run migrations before tests in this project"
+```
+Moves it from MEMORY.md (background note) to CLAUDE.md (enforced rule).
+
+### When you solved something non-obvious that could help other projects
+```
+/si:extract "Docker build fix for ARM64 platform mismatch"
+```
+Creates a standalone skill with SKILL.md, ready to install elsewhere.
+
+### To check memory capacity
+```
+/si:status
+```
+Shows line counts, topic files, stale entries, and recommendations.
+
+## Key principle
+
+**Don't fight auto-memory — orchestrate it.**
+
+- Auto-memory is great at capturing patterns. Let it do its job.
+- This plugin adds judgment: what's worth keeping, what should be promoted, what's stale.
+- Promoted rules in CLAUDE.md have higher priority than MEMORY.md entries.
+- Removing promoted entries from MEMORY.md frees space for new learnings.
+
+## Agents
+
+- **memory-analyst**: Spawned by `/si:review` to analyze patterns across memory files
+- **skill-extractor**: Spawned by `/si:extract` to generate complete skill packages
+
+## Hooks
+
+The `error-capture.sh` hook fires on `PostToolUse` (Bash only). It detects command failures and appends structured entries to auto-memory. Zero overhead on successful commands.
+
+When you install this plugin via `/plugin install self-improving-agent@claude-code-skills`, the hook is registered automatically from `.claude-plugin/hooks.json` — you don't need to configure anything manually.
+
+If you ever need to wire it up by hand (e.g. you copied the skill directly instead of installing as a plugin), use the `${CLAUDE_PLUGIN_ROOT}` variable so the path resolves against the plugin root rather than your current working directory:
+
+```json
+// .claude/settings.json
+{
+  "hooks": {
+    "PostToolUse": [{
+      "matcher": "Bash",
+      "hooks": [{
+        "type": "command",
+        "command": "${CLAUDE_PLUGIN_ROOT}/hooks/error-capture.sh"
+      }]
+    }]
+  }
+}
+```
+
+**Do not use a relative path like `./hooks/error-capture.sh`** — Claude Code resolves hook commands against the user's current working directory, not the plugin root. A relative path will silently fail (non-blocking) in every session started outside the plugin install dir.

package/engineering-team/self-improving-agent/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Reza Rezvani
+
+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/engineering-team/self-improving-agent/README.md

@@ -0,0 +1,92 @@
+# Self-Improving Agent
+
+> Auto-memory captures. This plugin curates.
+
+A Claude Code plugin that turns auto-memory into a structured self-improvement loop. Analyze what Claude has learned, promote proven patterns to enforced rules, and extract recurring solutions into reusable skills.
+
+## Why
+
+Claude Code's auto-memory (v2.1.32+) automatically records project patterns in `MEMORY.md`. But it has no judgment about what to keep, what to promote, or when entries go stale. This plugin adds the intelligence layer.
+
+**The difference:**
+- **MEMORY.md**: "I noticed this project uses pnpm" (background note, truncated at 200 lines)
+- **CLAUDE.md**: "Use pnpm, not npm" (enforced instruction, loaded in full)
+
+Promoting a pattern from memory to rules fundamentally changes how Claude treats it.
+
+## Commands
+
+| Command | What it does |
+|---------|-------------|
+| `/si:review` | Analyze auto-memory — find promotion candidates, stale entries, health metrics |
+| `/si:promote` | Graduate a pattern from MEMORY.md → CLAUDE.md or `.claude/rules/` |
+| `/si:extract` | Turn a recurring pattern into a standalone reusable skill |
+| `/si:status` | Memory health dashboard — line counts, capacity, recommendations |
+| `/si:remember` | Explicitly save important knowledge to auto-memory |
+
+## Install
+
+### Claude Code
+```
+/plugin marketplace add alirezarezvani/claude-skills
+/plugin install self-improving-agent@claude-code-skills
+```
+
+### OpenClaw
+```bash
+clawhub install self-improving-agent
+```
+
+### Codex CLI
+```bash
+./scripts/codex-install.sh --skill self-improving-agent
+```
+
+## How It Works
+
+```
+Claude discovers pattern → auto-memory (MEMORY.md)
+         ↓
+Pattern recurs 2-3x → /si:review flags it
+         ↓
+You approve → /si:promote graduates it to CLAUDE.md
+         ↓
+Pattern becomes enforced rule, memory entry removed
+         ↓
+Space freed for new learnings
+```
+
+## What's Included
+
+| Component | Count | Description |
+|-----------|-------|-------------|
+| Skills | 5 | review, promote, extract, status, remember |
+| Agents | 2 | memory-analyst, skill-extractor |
+| Hooks | 1 | PostToolUse error capture (zero overhead on success) |
+| Reference docs | 3 | memory architecture, promotion rules, rules directory patterns |
+| Templates | 2 | rule template, skill template |
+
+## Design Principles
+
+1. **Don't fight auto-memory — orchestrate it.** Auto-memory captures. This plugin curates.
+2. **No duplicate storage.** Reads from `~/.claude/projects/` directly. No `.learnings/` directory.
+3. **Zero capture overhead.** Auto-memory handles capture. Hook only fires on errors.
+4. **Promotion = graduation.** Moving a pattern from MEMORY.md to CLAUDE.md changes its priority.
+5. **Respect the 200-line limit.** Actively manages MEMORY.md capacity.
+
+## Platform Support
+
+| Platform | Memory System | Support |
+|----------|--------------|---------|
+| Claude Code | Auto-memory (MEMORY.md) | ✅ Full |
+| OpenClaw | workspace/MEMORY.md | ✅ Adapted |
+| Codex CLI | AGENTS.md | ✅ Adapted |
+| GitHub Copilot | copilot-instructions.md | ⚠️ Manual |
+
+## Credits
+
+Inspired by [pskoett/self-improving-agent](https://clawhub.ai/pskoett/self-improving-agent) — a structured learning loop for AI coding agents. This plugin builds on that concept by integrating natively with Claude Code's auto-memory system.
+
+## License
+
+MIT — see [LICENSE](LICENSE)

package/engineering-team/self-improving-agent/agents/memory-analyst.md

@@ -0,0 +1,82 @@
+---
+name: memory-analyst
+description: Read-only analyst for `~/.claude/projects/<project>/memory/`. Identifies promotion candidates (entries proven enough for CLAUDE.md), stale references, consolidation opportunities, conflicts with existing CLAUDE.md rules, and reports health metrics (capacity, freshness, organization). Spawned by `/si:review`.
+tools: Read, Glob, Grep
+model: inherit
+maxTurns: 30
+---
+
+# Memory Analyst Agent
+
+You are a memory analyst for Claude Code projects. Your job is to analyze the auto-memory directory and produce actionable insights.
+
+## Your Role
+
+You analyze `~/.claude/projects/<project>/memory/` to find:
+1. **Promotion candidates** — entries proven enough to become CLAUDE.md rules
+2. **Stale entries** — references to files, tools, or patterns that no longer apply
+3. **Consolidation opportunities** — multiple entries about the same topic
+4. **Conflicts** — memory entries that contradict CLAUDE.md rules
+5. **Health metrics** — capacity, freshness, organization
+
+## Analysis Process
+
+### 1. Read all memory files
+- `MEMORY.md` (main file, first 200 lines loaded at startup)
+- Any topic files (`debugging.md`, `patterns.md`, etc.)
+- Note total line counts and file sizes
+
+### 2. Cross-reference with CLAUDE.md
+- Read `./CLAUDE.md` and `~/.claude/CLAUDE.md`
+- Read all files in `.claude/rules/`
+- Identify duplicates, contradictions, and gaps
+
+### 3. Detect patterns
+For each MEMORY.md entry, evaluate:
+
+**Recurrence signals:**
+- Same concept in multiple entries (paraphrased)
+- Words like "again", "still", "always", "every time"
+- Similar entries in topic files
+
+**Staleness signals:**
+- File paths that don't exist on disk (verify with `find` or `ls`)
+- Version numbers that are outdated
+- References to removed dependencies
+- Patterns that contradict current CLAUDE.md
+
+**Promotion signals:**
+- Actionable (can be written as "Do X" / "Never Y")
+- Broadly applicable (not a one-time debugging note)
+- Not already in CLAUDE.md or rules/
+- High impact (prevents common mistakes)
+
+### 4. Score each entry
+
+Rate each entry on three dimensions:
+- **Durability** (0-3): Will this still be true in a month?
+- **Impact** (0-3): How much does this affect daily work?
+- **Scope** (0-3): Project-wide (3) vs. one-file (1) vs. one-time (0)
+
+Promotion candidates: total score ≥ 6
+
+### 5. Generate report
+
+Organize findings into:
+1. Promotion candidates (sorted by score, highest first)
+2. Stale entries (with reason for staleness)
+3. Consolidation groups (which entries to merge)
+4. Conflicts (with both sides shown)
+5. Health metrics (capacity, freshness)
+6. Recommendations (top 3 actions)
+
+## Output Format
+
+Use the format defined in the `/si:review` skill. Be specific — include line numbers, exact text, and concrete suggestions.
+
+## Constraints
+
+- Never modify files directly — only analyze and report
+- Don't invent entries — only report what's actually in the memory files
+- Be concise — the report should be shorter than the memory files it analyzes
+- Prioritize actionable findings over completeness

package/engineering-team/self-improving-agent/agents/skill-extractor.md

@@ -0,0 +1,133 @@
+---
+name: skill-extractor
+description: Transforms a proven pattern or debugging solution into a standalone, portable skill package. Generates `SKILL.md` with proper frontmatter, reference docs, and examples that work in any project (no hardcoded paths or project-specific values). Spawned by `/si:extract` when a recurring solution should become reusable.
+tools: Read, Write, Edit, Glob, Grep
+disallowedTools: Bash(rm *), Bash(rmdir *), Bash(curl *), Bash(wget *)
+model: inherit
+maxTurns: 30
+---
+
+# Skill Extractor Agent
+
+You are a skill extraction specialist. Your job is to transform proven patterns and debugging solutions into standalone, portable skills.
+
+## Your Role
+
+Given a pattern description (and optionally auto-memory entries), generate a complete skill package that:
+- Solves a specific, recurring problem
+- Works in any project (no hardcoded paths, credentials, or project-specific values)
+- Is self-contained (readable without the original context)
+- Follows the claude-skills format specification
+
+## Extraction Process
+
+### 1. Understand the pattern
+
+From the input, identify:
+- **The problem**: What goes wrong? What's the symptom?
+- **The root cause**: Why does it happen?
+- **The solution**: What's the fix? Are there multiple approaches?
+- **The edge cases**: When does the solution NOT work?
+- **The trigger conditions**: When should an agent use this skill?
+
+### 2. Generate skill name
+
+Rules:
+- Lowercase, hyphens between words
+- 2-4 words, descriptive
+- Match the problem, not the project
+- Examples: `docker-arm64-fixes`, `api-timeout-patterns`, `pnpm-monorepo-setup`
+
+**Reserved fragments — refuse to write any skill whose name contains:**
+- `claude` (any position)
+- `anthropic` (any position)
+
+These are reserved by the Claude Code skill spec. For skills about Claude
+Code itself, use the `cc-` prefix:
+- ❌ `claude-code-settings` → ✅ `cc-settings`
+- ❌ `claude-mcp-tools` → ✅ `cc-mcp-tools`
+
+Validate the proposed `name` against this rule **before** creating any file.
+If the input pattern implies a reserved fragment, rewrite to `cc-*` and
+surface the rename in your report.
+
+### 3. Create SKILL.md
+
+Required structure:
+
+```markdown
+---
+name: {{skill-name}}
+description: "{{One sentence}}. Use when: {{trigger conditions}}."
+---
+
+# {{Skill Title}}
+
+> {{One-line value proposition}}
+
+## Quick Reference
+
+| Problem | Solution |
+|---------|----------|
+| {{error/symptom}} | {{fix}} |
+
+## The Problem
+
+{{2-3 sentences. Include the error message or symptom people would search for.}}
+
+## Solutions
+
+### Option 1: {{Name}} (Recommended)
+
+{{Step-by-step instructions with code blocks.}}
+
+### Option 2: {{Alternative}} {{if applicable}}
+
+{{When Option 1 doesn't apply.}}
+
+## Trade-offs
+
+| Approach | Pros | Cons |
+|----------|------|------|
+| {{option}} | {{pros}} | {{cons}} |
+
+## Edge Cases
+
+- {{When this approach breaks and what to do instead}}
+
+## Related
+
+- {{Links to official docs or related skills}}
+```
+
+### 4. Create README.md
+
+Brief human-readable overview:
+- What the skill does (1 paragraph)
+- Installation instructions
+- When to use it
+- Credits/source
+
+### 5. Quality checks
+
+Before delivering, verify:
+
+- [ ] YAML frontmatter is valid (`name` and `description` present)
+- [ ] `name` in frontmatter matches folder name
+- [ ] `name` does NOT contain reserved fragments `claude` or `anthropic`
+- [ ] Description includes "Use when:" trigger
+- [ ] No project-specific paths, URLs, or credentials
+- [ ] Code examples are complete and runnable
+- [ ] Error messages are exact (copy-pasteable for searching)
+- [ ] Solutions work without additional context
+- [ ] Trade-offs table helps users choose between options
+- [ ] Skill is useful in a project you've never seen before
+
+## Constraints
+
+- **One problem per skill** — don't create omnibus guides
+- **Show, don't tell** — code examples over prose
+- **Include the error** — people search by error message
+- **Be portable** — no `npm` vs `pnpm` assumptions
+- **Keep it short** — under 200 lines for SKILL.md
+- **No unnecessary files** — only SKILL.md is required. Add reference/ only if the topic is complex enough to warrant it

package/engineering-team/self-improving-agent/hooks/error-capture.sh

@@ -0,0 +1,119 @@
+#!/bin/bash
+# Self-Improving Agent — Error Capture Hook
+# Fires on PostToolUse (Bash) to detect command failures.
+# Zero output on success — only captures when errors are detected.
+#
+# When installed via `/plugin install self-improving-agent@claude-code-skills`
+# this hook is registered automatically from the plugin's hooks.json. No
+# manual wiring is required.
+#
+# If you need to wire it up manually, use ${CLAUDE_PLUGIN_ROOT} — a relative
+# path like ./hooks/error-capture.sh resolves against your current working
+# directory, not the plugin root, and will silently fail in every session
+# started outside the plugin install dir.
+#
+#   .claude/settings.json:
+#   {
+#     "hooks": {
+#       "PostToolUse": [{
+#         "matcher": "Bash",
+#         "hooks": [{
+#           "type": "command",
+#           "command": "${CLAUDE_PLUGIN_ROOT}/hooks/error-capture.sh"
+#         }]
+#       }]
+#     }
+#   }
+
+set -e
+
+OUTPUT="${CLAUDE_TOOL_OUTPUT:-}"
+
+# Exit silently if no output or empty
+[ -z "$OUTPUT" ] && exit 0
+
+# Error patterns — ordered by specificity
+ERROR_PATTERNS=(
+    "error:"
+    "Error:"
+    "ERROR:"
+    "FATAL:"
+    "fatal:"
+    "FAILED"
+    "failed"
+    "command not found"
+    "No such file or directory"
+    "Permission denied"
+    "Module not found"
+    "ModuleNotFoundError"
+    "ImportError"
+    "SyntaxError"
+    "TypeError"
+    "ReferenceError"
+    "Cannot find module"
+    "ENOENT"
+    "EACCES"
+    "ECONNREFUSED"
+    "ETIMEDOUT"
+    "npm ERR!"
+    "pnpm ERR!"
+    "Traceback (most recent call last)"
+    "panic:"
+    "segmentation fault"
+    "core dumped"
+    "exit code"
+    "non-zero exit"
+    "Build failed"
+    "Compilation failed"
+    "Test failed"
+)
+
+# False positive exclusions — don't trigger on these
+EXCLUSIONS=(
+    "error-capture"       # Don't trigger on ourselves
+    "error_handler"       # Code that handles errors
+    "errorHandler"
+    "error.log"           # Log file references
+    "console.error"       # Code that logs errors
+    "catch (error"        # Error handling code
+    "catch (err"
+    ".error("             # Logger calls
+    "no error"            # Absence of error
+    "without error"
+    "error-free"
+)
+
+# Check exclusions first
+for excl in "${EXCLUSIONS[@]}"; do
+    if [[ "$OUTPUT" == *"$excl"* ]]; then
+        exit 0
+    fi
+done
+
+# Check for error patterns
+contains_error=false
+matched_pattern=""
+for pattern in "${ERROR_PATTERNS[@]}"; do
+    if [[ "$OUTPUT" == *"$pattern"* ]]; then
+        contains_error=true
+        matched_pattern="$pattern"
+        break
+    fi
+done
+
+# Exit silently if no error
+[ "$contains_error" = false ] && exit 0
+
+# Extract relevant error context (first 5 lines containing the pattern)
+error_context=$(echo "$OUTPUT" | grep -i -m 5 "$matched_pattern" | head -5)
+
+# Output a concise reminder — ~40 tokens
+cat << EOF
+<error-detected>
+Command error detected (pattern: "$matched_pattern").
+If this was unexpected or required investigation to fix, save the solution:
+  /si:remember "explanation of what went wrong and the fix"
+Or if this is a known pattern, check: /si:review
+Context: $(echo "$error_context" | head -2 | tr '\n' ' ' | cut -c1-200)
+</error-detected>
+EOF

package/engineering-team/self-improving-agent/hooks/hooks.json

@@ -0,0 +1,15 @@
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/error-capture.sh"
+          }
+        ]
+      }
+    ]
+  }
+}