npm - opencodekit - Versions diffs - 0.21.9 → 0.22.0 - Mend

opencodekit 0.21.9 → 0.22.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (165) hide show

package/dist/template/.opencode/skill/index-knowledge/SKILL.md DELETED Viewed

@@ -1,413 +0,0 @@
----
-name: index-knowledge
-description: Use when generating or refreshing AGENTS.md knowledge bases for a codebase. MUST load before creating hierarchical documentation or complexity-scored subdirectory guides.
-version: 1.0.0
-tags: [documentation, workflow]
-dependencies: []
----
-# index-knowledge
-## When to Use
-- When you need to generate or update hierarchical AGENTS.md documentation for a codebase.
-## When NOT to Use
-- When only a single small directory needs a manual note instead of a full knowledge hierarchy.
-## Usage
-```
-/index-knowledge                  # Update mode (default)
-/index-knowledge --create-new     # Delete all → regenerate from scratch
-/index-knowledge --max-depth=2    # Limit directory depth (default: 5)
-```
-## Load Skills
-```typescript
-skill({ name: "memory-system" }); // Search for existing patterns
-skill({ name: "deep-research" }); // For thorough LSP exploration
-```
-## Check Memory First
-```typescript
-memory_search({ query: "AGENTS.md conventions patterns", limit: 3 });
-```
----
-## Workflow (High-Level)
-1. **Discovery + Analysis** (concurrent)
-   - Launch parallel explore agents (multiple Task calls in one message)
-   - Main session: bash structure + LSP codemap + read existing AGENTS.md
-2. **Score & Decide** - Determine AGENTS.md locations from merged findings
-3. **Generate** - Root first, then subdirs in parallel
-4. **Review** - Deduplicate, trim, validate
-<critical>
-**TodoWrite ALL phases. Mark in_progress → completed in real-time.**
-```typescript
-todowrite({ todos: [
-  { id: "discovery", content: "Fire explore agents + LSP codemap + read existing", status: "pending", priority: "high" },
-  { id: "scoring", content: "Score directories, determine locations", status: "pending", priority: "high" },
-  { id: "generate", content: "Generate AGENTS.md files (root + subdirs)", status: "pending", priority: "high" },
-  { id: "review", content: "Deduplicate, validate, trim", status: "pending", priority: "medium" }
-]});
-```
-</critical>
----
-## Phase 1: Discovery + Analysis (Concurrent)
-**Mark "discovery" as in_progress.**
-### Launch Parallel Explore Agents
-Multiple Task calls in a single message execute in parallel. Results return directly.
-```
-// All Task calls in ONE message = parallel execution
-Task(
-  description="project structure",
-  subagent_type="explore",
-  prompt="Project structure: PREDICT standard patterns for detected language → REPORT deviations only"
-)
-Task(
-  description="entry points",
-  subagent_type="explore",
-  prompt="Entry points: FIND main files → REPORT non-standard organization"
-)
-Task(
-  description="conventions",
-  subagent_type="explore",
-  prompt="Conventions: FIND config files (.eslintrc, pyproject.toml, .editorconfig) → REPORT project-specific rules"
-)
-Task(
-  description="anti-patterns",
-  subagent_type="explore",
-  prompt="Anti-patterns: FIND 'DO NOT', 'NEVER', 'ALWAYS', 'DEPRECATED' comments → LIST forbidden patterns"
-)
-Task(
-  description="build/ci",
-  subagent_type="explore",
-  prompt="Build/CI: FIND .github/workflows, Makefile → REPORT non-standard patterns"
-)
-Task(
-  description="test patterns",
-  subagent_type="explore",
-  prompt="Test patterns: FIND test configs, test structure → REPORT unique conventions"
-)
-```
-<dynamic-agents>
-**DYNAMIC AGENT SPAWNING**: After bash analysis, spawn ADDITIONAL explore agents based on project scale:
-| Factor                       | Threshold | Additional Agents          |
-| ---------------------------- | --------- | -------------------------- |
-| **Total files**              | >100      | +1 per 100 files           |
-| **Total lines**              | >10k      | +1 per 10k lines           |
-| **Directory depth**          | ≥4        | +2 for deep exploration    |
-| **Large files (>500 lines)** | >10 files | +1 for complexity hotspots |
-| **Monorepo**                 | detected  | +1 per package/workspace   |
-| **Multiple languages**       | >1        | +1 per language            |
-```bash
-# Measure project scale first
-total_files=$(find . -type f -not -path '*/node_modules/*' -not -path '*/.git/*' | wc -l)
-total_lines=$(find . -type f \( -name "*.ts" -o -name "*.py" -o -name "*.go" \) -not -path '*/node_modules/*' -exec wc -l {} + 2>/dev/null | tail -1 | awk '{print $1}')
-large_files=$(find . -type f \( -name "*.ts" -o -name "*.py" \) -not -path '*/node_modules/*' -exec wc -l {} + 2>/dev/null | awk '$1 > 500 {count++} END {print count+0}')
-max_depth=$(find . -type d -not -path '*/node_modules/*' -not -path '*/.git/*' | awk -F/ '{print NF}' | sort -rn | head -1)
-```
-Example spawning (all in ONE message for parallel execution):
-```
-// 500 files, 50k lines, depth 6, 15 large files → spawn additional agents
-Task(
-  description="large files",
-  subagent_type="explore",
-  prompt="Large file analysis: FIND files >500 lines, REPORT complexity hotspots"
-)
-Task(
-  description="deep modules",
-  subagent_type="explore",
-  prompt="Deep modules at depth 4+: FIND hidden patterns, internal conventions"
-)
-Task(
-  description="cross-cutting",
-  subagent_type="explore",
-  prompt="Cross-cutting concerns: FIND shared utilities across directories"
-)
-// ... more based on calculation
-```
-</dynamic-agents>
-### Main Session: Concurrent Analysis
-**While Task agents execute**, main session does:
-#### 1. Bash Structural Analysis
-```bash
-# Directory depth + file counts
-find . -type d -not -path '*/\.*' -not -path '*/node_modules/*' -not -path '*/venv/*' -not -path '*/dist/*' -not -path '*/build/*' | awk -F/ '{print NF-1}' | sort -n | uniq -c
-# Files per directory (top 30)
-find . -type f -not -path '*/\.*' -not -path '*/node_modules/*' | sed 's|/[^/]*$||' | sort | uniq -c | sort -rn | head -30
-# Code concentration by extension
-find . -type f \( -name "*.py" -o -name "*.ts" -o -name "*.tsx" -o -name "*.js" -o -name "*.go" -o -name "*.rs" \) -not -path '*/node_modules/*' | sed 's|/[^/]*$||' | sort | uniq -c | sort -rn | head -20
-# Existing AGENTS.md / CLAUDE.md
-find . -type f \( -name "AGENTS.md" -o -name "CLAUDE.md" \) -not -path '*/node_modules/*' 2>/dev/null
-```
-#### 2. Read Existing AGENTS.md
-```
-For each existing file found:
-  Read(filePath=file)
-  Extract: key insights, conventions, anti-patterns
-  Store in EXISTING_AGENTS map
-```
-If `--create-new`: Read all existing first (preserve context) → then delete all → regenerate.
-#### 3. LSP Codemap (if available)
-```
-lsp_servers()  # Check availability
-# Entry points (parallel)
-lsp_document_symbols(filePath="src/index.ts")
-lsp_document_symbols(filePath="main.py")
-# Key symbols (parallel)
-lsp_workspace_symbols(filePath=".", query="class")
-lsp_workspace_symbols(filePath=".", query="interface")
-lsp_workspace_symbols(filePath=".", query="function")
-# Centrality for top exports
-lsp_find_references(filePath="...", line=X, character=Y)
-```
-**LSP Fallback**: If unavailable, rely on explore agents + AST-grep.
-**Merge: bash + LSP + existing + Task agent results. Mark "discovery" as completed.**
----
-## Phase 2: Scoring & Location Decision
-**Mark "scoring" as in_progress.**
-### Scoring Matrix
-| Factor               | Weight | High Threshold           | Source  |
-| -------------------- | ------ | ------------------------ | ------- |
-| File count           | 3x     | >20                      | bash    |
-| Subdir count         | 2x     | >5                       | bash    |
-| Code ratio           | 2x     | >70%                     | bash    |
-| Unique patterns      | 1x     | Has own config           | explore |
-| Module boundary      | 2x     | Has index.ts/**init**.py | bash    |
-| Symbol density       | 2x     | >30 symbols              | LSP     |
-| Export count         | 2x     | >10 exports              | LSP     |
-| Reference centrality | 3x     | >20 refs                 | LSP     |
-### Decision Rules
-| Score        | Action                    |
-| ------------ | ------------------------- |
-| **Root (.)** | ALWAYS create             |
-| **>15**      | Create AGENTS.md          |
-| **8-15**     | Create if distinct domain |
-| **<8**       | Skip (parent covers)      |
-### Output
-```
-AGENTS_LOCATIONS = [
-  { path: ".", type: "root" },
-  { path: "src/hooks", score: 18, reason: "high complexity" },
-  { path: "src/api", score: 12, reason: "distinct domain" }
-]
-```
-**Mark "scoring" as completed.**
----
-## Phase 3: Generate AGENTS.md
-**Mark "generate" as in_progress.**
-### Root AGENTS.md (Full Treatment)
-```markdown
-# PROJECT KNOWLEDGE BASE
-**Generated:** {TIMESTAMP}
-**Commit:** {SHORT_SHA}
-**Branch:** {BRANCH}
-## OVERVIEW
-{1-2 sentences: what + core stack}
-## STRUCTURE
-\`\`\`
-{root}/
-├── {dir}/ # {non-obvious purpose only}
-└── {entry}
-\`\`\`
-## WHERE TO LOOK
-| Task | Location | Notes |
-| ---- | -------- | ----- |
-## CODE MAP
-{From LSP - skip if unavailable or project <10 files}
-| Symbol | Type | Location | Refs | Role |
-## CONVENTIONS
-{ONLY deviations from standard}
-## ANTI-PATTERNS (THIS PROJECT)
-{Explicitly forbidden here}
-## UNIQUE STYLES
-{Project-specific}
-## COMMANDS
-\`\`\`bash
-{dev/test/build}
-\`\`\`
-## NOTES
-{Gotchas}
-```
-**Quality gates**: 50-150 lines, no generic advice, no obvious info.
-### Subdirectory AGENTS.md (Parallel)
-Launch general agents for each location in ONE message (parallel execution):
-```
-// All in single message = parallel
-Task(
-  description="AGENTS.md for src/hooks",
-  subagent_type="general",
-  prompt="Generate AGENTS.md for: src/hooks
-    - Reason: high complexity
-    - 30-80 lines max
-    - NEVER repeat parent content
-    - Sections: OVERVIEW (1 line), STRUCTURE (if >5 subdirs), WHERE TO LOOK, CONVENTIONS (if different), ANTI-PATTERNS
-    - Write directly to src/hooks/AGENTS.md"
-)
-Task(
-  description="AGENTS.md for src/api",
-  subagent_type="general",
-  prompt="Generate AGENTS.md for: src/api
-    - Reason: distinct domain
-    - 30-80 lines max
-    - NEVER repeat parent content
-    - Sections: OVERVIEW (1 line), STRUCTURE (if >5 subdirs), WHERE TO LOOK, CONVENTIONS (if different), ANTI-PATTERNS
-    - Write directly to src/api/AGENTS.md"
-)
-// ... one Task per AGENTS_LOCATIONS entry
-```
-**Results return directly. Mark "generate" as completed.**
----
-## Phase 4: Review & Deduplicate
-**Mark "review" as in_progress.**
-For each generated file:
-- Remove generic advice
-- Remove parent duplicates
-- Trim to size limits
-- Verify telegraphic style
-**Mark "review" as completed.**
----
-## Final Report
-```
-=== index-knowledge Complete ===
-Mode: {update | create-new}
-Files:
-  ✓ ./AGENTS.md (root, {N} lines)
-  ✓ ./src/hooks/AGENTS.md ({N} lines)
-Dirs Analyzed: {N}
-AGENTS.md Created: {N}
-AGENTS.md Updated: {N}
-Hierarchy:
-  ./AGENTS.md
-  └── src/hooks/AGENTS.md
-```
----
-## Anti-Patterns
-- **Static agent count**: MUST vary agents based on project size/depth
-- **Sequential execution**: MUST parallel (multiple Task calls in one message)
-- **Ignoring existing**: ALWAYS read existing first, even with --create-new
-- **Over-documenting**: Not every dir needs AGENTS.md
-- **Redundancy**: Child never repeats parent
-- **Generic content**: Remove anything that applies to ALL projects
-- **Verbose style**: Telegraphic or die
-- **Skipping memory**: ALWAYS search memory for existing patterns before starting
----
-## Record Findings
-After completion, save significant discoveries:
-```typescript
-observation({
-  type: "pattern",
-  title: "AGENTS.md patterns for [project]",
-  narrative: "[Key conventions, anti-patterns, structure decisions]",
-  concepts: "AGENTS.md, documentation, codebase, knowledge",
-  confidence: "high",
-});
-```

package/dist/template/.opencode/skill/memory-grounding/SKILL.md DELETED Viewed

@@ -1,68 +0,0 @@
----
-name: memory-grounding
-description: >
-  Use at the start of any command that needs prior context — searches memory for decisions, patterns, and handoffs before execution to avoid re-solving solved problems.
-version: 1.0.0
-tags: [memory, grounding, pre-flight]
----
-# Memory Grounding
-Search institutional memory before executing any command that modifies state or makes decisions.
-## When to Use
-- At the start of `/ship`, `/plan`, `/create`, `/pr`, `/research`, `/resume`
-- Before any command that benefits from prior context
-- When you need to check if work was already done or decisions already made
-## When NOT to Use
-- Read-only commands that don't need historical context (e.g., `/status`)
-- Commands that explicitly skip grounding (e.g., `--no-memory` flag)
-## Protocol
-### Step 1: Search for relevant context
-```typescript
-// Primary: search by bead ID or topic
-memory-search({ query: "$ARGUMENTS" });
-// Secondary: search by keywords with limit
-memory-search({ query: "<feature or topic keywords>", limit: 5 });
-// Optional: filter by type for specific needs
-memory-search({ query: "<keywords>", type: "decision" });  // Past decisions
-memory-search({ query: "<keywords>", type: "bugfix" });    // Known issues
-```
-### Step 2: Check last session handoff
-```typescript
-memory-read({ file: "handoffs/last" });
-```
-### Step 3: Check session history (if resuming work)
-```typescript
-find_sessions({ query: "$ARGUMENTS", limit: 3 });
-```
-### Step 4: Apply findings
-- **If relevant findings exist:** Incorporate them directly. Don't re-solve solved problems.
-- **If prior decisions found:** Follow them unless there's a clear reason to diverge (document the divergence).
-- **If known issues found:** Account for them in the current approach.
-- **If nothing found:** Proceed normally — absence of memory is not a blocker.
-## Command-Specific Variations
-| Command     | Extra Focus                                            |
-| ----------- | ------------------------------------------------------ |
-| `/plan`     | Search bugfixes; check for existing plans to overwrite |
-| `/ship`     | Search for failed approaches to avoid repeating        |
-| `/create`   | Search for duplicate beads before creating             |
-| `/pr`       | Include findings in PR description                     |
-| `/research` | Search before spawning agents; narrow scope to gaps    |
-| `/resume`   | Read handoff file by bead ID; check session history    |

package/dist/template/.opencode/skill/playwriter/SKILL.md DELETED Viewed

@@ -1,158 +0,0 @@
----
-name: playwriter
-description: Use when you need browser automation using the user's existing Chrome with extensions, sessions, and cookies intact. 90% less context than traditional browser MCP. Prefer over playwright skill when existing session state matters.
-mcp:
-  playwriter:
-    command: npx
-    args: ["playwriter@latest"]
-version: 1.0.0
-tags: [automation, mcp]
-dependencies: []
----
-# Playwriter Browser Automation (MCP)
-## When to Use
-- When you need to automate your existing Chrome browser session via the Playwriter extension.
-## When NOT to Use
-- When you need a fresh, isolated browser instance without your local extensions/cookies.
-- **Uses your existing browser** - extensions, sessions, cookies all work
-- **Single `execute` tool** - send Playwright code snippets directly
-- **90% less context** - no tool schema bloat
-- **Full Playwright API** - LLMs already know it from training
-- **Bypass automation detection** - disconnect extension when needed
-## Prerequisites
-**You must install the Chrome extension first:**
-1. Install [Playwriter Extension](https://chromewebstore.google.com/detail/playwriter-mcp/jfeammnjpkecdekppnclgkkffahnhfhe)
-2. Click extension icon on tabs you want to control (icon turns green)
-3. Now the skill can interact with those tabs
-## Quick Start
-After loading this skill:
-```
-# List available tabs (enabled ones)
-skill_mcp(skill_name="playwriter", tool_name="listTabs")
-# Execute Playwright code on a tab
-skill_mcp(skill_name="playwriter", tool_name="execute", arguments='{"tabId": "tab-id-here", "code": "await page.goto(\"https://example.com\")"}')
-```
-## Available Tools
-| Tool       | Description                      | Arguments                         |
-| ---------- | -------------------------------- | --------------------------------- |
-| `listTabs` | List tabs with extension enabled | `{}`                              |
-| `execute`  | Run Playwright code snippet      | `{"tabId": "...", "code": "..."}` |
-That's it. Two tools. The power is in the Playwright code you send.
-## The `execute` Pattern
-Send any valid Playwright code. The `page` object is already available:
-```javascript
-// Navigate
-await page.goto("https://github.com");
-// Click
-await page.click("button.sign-in");
-// Fill form
-await page.fill("#email", "user@example.com");
-await page.fill("#password", "secret");
-await page.click('button[type="submit"]');
-// Wait for element
-await page.waitForSelector(".dashboard");
-// Get text
-const title = await page.title();
-// Screenshot
-await page.screenshot({ path: "/tmp/screenshot.png" });
-// Complex selectors
-await page.click("text=Submit");
-await page.click('[data-testid="login-btn"]');
-// Evaluate JS in page
-const links = await page.evaluate(() =>
-  Array.from(document.querySelectorAll("a")).map((a) => a.href),
-);
-```
-## Examples
-### Navigate and Screenshot
-```
-skill_mcp(skill_name="playwriter", tool_name="execute", arguments='{"tabId": "abc123", "code": "await page.goto(\"https://example.com\"); await page.screenshot({ path: \"/tmp/example.png\" })"}')
-```
-### Fill a Form
-```
-skill_mcp(skill_name="playwriter", tool_name="execute", arguments='{"tabId": "abc123", "code": "await page.fill(\"#name\", \"John Doe\"); await page.fill(\"#email\", \"john@example.com\"); await page.click(\"button[type=submit]\")"}')
-```
-### Login Flow (Using Your Saved Sessions)
-```
-# If you're already logged in via browser, just navigate
-skill_mcp(skill_name="playwriter", tool_name="execute", arguments='{"tabId": "abc123", "code": "await page.goto(\"https://github.com/settings/profile\")"}')
-# Your cookies/session already work - no login needed!
-```
-### Scrape Data
-```
-skill_mcp(skill_name="playwriter", tool_name="execute", arguments='{"tabId": "abc123", "code": "const items = await page.$$eval(\".product\", els => els.map(e => ({ name: e.querySelector(\"h2\").textContent, price: e.querySelector(\".price\").textContent }))); return items"}')
-```
-### Test Responsive
-```
-skill_mcp(skill_name="playwriter", tool_name="execute", arguments='{"tabId": "abc123", "code": "await page.setViewportSize({ width: 375, height: 667 }); await page.screenshot({ path: \"/tmp/mobile.png\" })"}')
-```
-## Bypassing Automation Detection
-For sites that detect automation (Google login, etc.):
-1. **Disconnect the extension** before sensitive actions
-2. Perform login manually
-3. **Reconnect** after authentication
-4. Continue automation with your authenticated session
-This works because the browser is real - not a Puppeteer/Playwright-spawned instance.
-## vs Traditional Playwright MCP
-| Aspect               | `playwright` skill      | `playwriter` skill      |
-| -------------------- | ----------------------- | ----------------------- |
-| Tools                | 17+                     | 2                       |
-| Context usage        | High                    | ~90% less               |
-| Browser              | New instance            | Your existing browser   |
-| Extensions           | None                    | All yours               |
-| Sessions/cookies     | Fresh                   | Your logged-in sessions |
-| Automation detection | Always detected         | Can bypass              |
-| API knowledge        | Must learn tool schemas | Standard Playwright     |
-## Tips
-- **List tabs first** to get valid tabId values
-- **Chain commands** in single execute for efficiency
-- **Use your sessions** - if you're logged into GitHub in Chrome, it just works
-- **Return data** from execute to get values back
-- **Standard Playwright docs** apply - no special syntax to learn