@agentskillkit/agent-skills 1.0.1 → 3.2.1

package/.agent/skills/seo-fundamentals/scripts/seo_checker.py

@@ -1,219 +0,0 @@
-#!/usr/bin/env python3
-"""
-SEO Checker - Search Engine Optimization Audit
-Checks HTML/JSX/TSX pages for SEO best practices.
-
-PURPOSE:
-    - Verify meta tags, titles, descriptions
-    - Check Open Graph tags for social sharing
-    - Validate heading hierarchy
-    - Check image accessibility (alt attributes)
-
-WHAT IT CHECKS:
-    - HTML files (actual web pages)
-    - JSX/TSX files (React page components)
-    - Only files that are likely PUBLIC pages
-
-Usage:
-    python seo_checker.py <project_path>
-"""
-import sys
-import json
-import re
-from pathlib import Path
-from datetime import datetime
-
-# Fix Windows console encoding
-try:
-    sys.stdout.reconfigure(encoding='utf-8', errors='replace')
-except:
-    pass
-
-
-# Directories to skip
-SKIP_DIRS = {
-    'node_modules', '.next', 'dist', 'build', '.git', '.github',
-    '__pycache__', '.vscode', '.idea', 'coverage', 'test', 'tests',
-    '__tests__', 'spec', 'docs', 'documentation', 'examples'
-}
-
-# Files to skip (not pages)
-SKIP_PATTERNS = [
-    'config', 'setup', 'util', 'helper', 'hook', 'context', 'store',
-    'service', 'api', 'lib', 'constant', 'type', 'interface', 'mock',
-    '.test.', '.spec.', '_test.', '_spec.'
-]
-
-
-def is_page_file(file_path: Path) -> bool:
-    """Check if this file is likely a public-facing page."""
-    name = file_path.name.lower()
-    stem = file_path.stem.lower()
-    
-    # Skip utility/config files
-    if any(skip in name for skip in SKIP_PATTERNS):
-        return False
-    
-    # Check path - pages in specific directories are likely pages
-    parts = [p.lower() for p in file_path.parts]
-    page_dirs = ['pages', 'app', 'routes', 'views', 'screens']
-    
-    if any(d in parts for d in page_dirs):
-        return True
-    
-    # Filename indicators for pages
-    page_names = ['page', 'index', 'home', 'about', 'contact', 'blog', 
-                  'post', 'article', 'product', 'landing', 'layout']
-    
-    if any(p in stem for p in page_names):
-        return True
-    
-    # HTML files are usually pages
-    if file_path.suffix.lower() in ['.html', '.htm']:
-        return True
-    
-    return False
-
-
-def find_pages(project_path: Path) -> list:
-    """Find page files to check."""
-    patterns = ['**/*.html', '**/*.htm', '**/*.jsx', '**/*.tsx']
-    
-    files = []
-    for pattern in patterns:
-        for f in project_path.glob(pattern):
-            # Skip excluded directories
-            if any(skip in f.parts for skip in SKIP_DIRS):
-                continue
-            
-            # Check if it's likely a page
-            if is_page_file(f):
-                files.append(f)
-    
-    return files[:50]  # Limit to 50 files
-
-
-def check_page(file_path: Path) -> dict:
-    """Check a single page for SEO issues."""
-    issues = []
-    
-    try:
-        content = file_path.read_text(encoding='utf-8', errors='ignore')
-    except Exception as e:
-        return {"file": str(file_path.name), "issues": [f"Error: {e}"]}
-    
-    # Detect if this is a layout/template file (has Head component)
-    is_layout = 'Head>' in content or '<head' in content.lower()
-    
-    # 1. Title tag
-    has_title = '<title' in content.lower() or 'title=' in content or 'Head>' in content
-    if not has_title and is_layout:
-        issues.append("Missing <title> tag")
-    
-    # 2. Meta description
-    has_description = 'name="description"' in content.lower() or 'name=\'description\'' in content.lower()
-    if not has_description and is_layout:
-        issues.append("Missing meta description")
-    
-    # 3. Open Graph tags
-    has_og = 'og:' in content or 'property="og:' in content.lower()
-    if not has_og and is_layout:
-        issues.append("Missing Open Graph tags")
-    
-    # 4. Heading hierarchy - multiple H1s
-    h1_matches = re.findall(r'<h1[^>]*>', content, re.I)
-    if len(h1_matches) > 1:
-        issues.append(f"Multiple H1 tags ({len(h1_matches)})")
-    
-    # 5. Images without alt
-    img_pattern = r'<img[^>]+>'
-    imgs = re.findall(img_pattern, content, re.I)
-    for img in imgs:
-        if 'alt=' not in img.lower():
-            issues.append("Image missing alt attribute")
-            break
-        if 'alt=""' in img or "alt=''" in img:
-            issues.append("Image has empty alt attribute")
-            break
-    
-    # 6. Check for canonical link (nice to have)
-    # has_canonical = 'rel="canonical"' in content.lower()
-    
-    return {
-        "file": str(file_path.name),
-        "issues": issues
-    }
-
-
-def main():
-    project_path = Path(sys.argv[1] if len(sys.argv) > 1 else ".").resolve()
-    
-    print(f"\n{'='*60}")
-    print(f"  SEO CHECKER - Search Engine Optimization Audit")
-    print(f"{'='*60}")
-    print(f"Project: {project_path}")
-    print(f"Time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
-    print("-"*60)
-    
-    # Find pages
-    pages = find_pages(project_path)
-    
-    if not pages:
-        print("\n[!] No page files found.")
-        print("    Looking for: HTML, JSX, TSX in pages/app/routes directories")
-        output = {"script": "seo_checker", "files_checked": 0, "passed": True}
-        print("\n" + json.dumps(output, indent=2))
-        sys.exit(0)
-    
-    print(f"Found {len(pages)} page files to analyze\n")
-    
-    # Check each page
-    all_issues = []
-    for f in pages:
-        result = check_page(f)
-        if result["issues"]:
-            all_issues.append(result)
-    
-    # Summary
-    print("=" * 60)
-    print("SEO ANALYSIS RESULTS")
-    print("=" * 60)
-    
-    if all_issues:
-        # Group by issue type
-        issue_counts = {}
-        for item in all_issues:
-            for issue in item["issues"]:
-                issue_counts[issue] = issue_counts.get(issue, 0) + 1
-        
-        print("\nIssue Summary:")
-        for issue, count in sorted(issue_counts.items(), key=lambda x: -x[1]):
-            print(f"  [{count}] {issue}")
-        
-        print(f"\nAffected files ({len(all_issues)}):")
-        for item in all_issues[:5]:
-            print(f"  - {item['file']}")
-        if len(all_issues) > 5:
-            print(f"  ... and {len(all_issues) - 5} more")
-    else:
-        print("\n[OK] No SEO issues found!")
-    
-    total_issues = sum(len(item["issues"]) for item in all_issues)
-    passed = total_issues == 0
-    
-    output = {
-        "script": "seo_checker",
-        "project": str(project_path),
-        "files_checked": len(pages),
-        "files_with_issues": len(all_issues),
-        "issues_found": total_issues,
-        "passed": passed
-    }
-    
-    print("\n" + json.dumps(output, indent=2))
-    
-    sys.exit(0 if passed else 1)
-
-
-if __name__ == "__main__":
-    main()

package/.agent/skills/sequential-thinking/README.md

@@ -1,118 +0,0 @@
-# Sequential Thinking Skill
-
-Agent skill for systematic problem-solving through iterative reasoning with revision and branching capabilities.
-
-## What This Skill Does
-
-Enables Claude to break down complex problems into sequential thought steps, revise conclusions when needed, and explore alternative solution paths—all while maintaining context throughout the reasoning process.
-
-## Installation
-
-This skill requires the Sequential Thinking MCP server to be installed and configured in your Claude Desktop or Claude Code environment.
-
-### Step 1: Install MCP Server
-
-Choose one of the following methods:
-
-#### NPX (Recommended)
-
-Add to your `claude_desktop_config.json` or MCP settings:
-
-```json
-{
-  "mcpServers": {
-    "sequential-thinking": {
-      "command": "npx",
-      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
-    }
-  }
-}
-```
-
-#### Docker
-
-```json
-{
-  "mcpServers": {
-    "sequentialthinking": {
-      "command": "docker",
-      "args": ["run", "--rm", "-i", "mcp/sequentialthinking"]
-    }
-  }
-}
-```
-
-### Step 2: Add Skill to Project
-
-Copy this skill folder to your project's `.claude/skills/` directory:
-
-```bash
-cp -r sequential-thinking /path/to/your/project/.claude/skills/
-```
-
-### Step 3: Verify Installation
-
-Restart Claude and check that the `mcp__reasoning__sequentialthinking` tool is available.
-
-## Usage
-
-Once installed, Claude will automatically use this skill when:
-- Facing complex multi-step problems
-- Needing to revise earlier conclusions
-- Exploring alternative solution approaches
-- Working through uncertain or evolving scopes
-
-You can also explicitly request it:
-```
-"Let's think through this step-by-step using sequential thinking"
-```
-
-## Configuration
-
-### Disable Logging (Optional)
-
-To suppress thought information logging, set environment variable:
-
-```json
-{
-  "mcpServers": {
-    "sequential-thinking": {
-      "command": "npx",
-      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"],
-      "env": {
-        "DISABLE_THOUGHT_LOGGING": "true"
-      }
-    }
-  }
-}
-```
-
-## Skill Structure
-
-```
-sequential-thinking/
-├── SKILL.md              # Main skill definition
-├── README.md             # This file
-└── references/
-    ├── advanced.md       # Revision and branching patterns
-    └── examples.md       # Real-world use cases
-```
-
-## When Claude Uses This Skill
-
-The skill activates for:
-- **Complex analysis**: Breaking down multi-faceted problems
-- **Design decisions**: Exploring and comparing alternatives
-- **Debugging**: Systematic investigation with course correction
-- **Planning**: Multi-stage project planning with evolving scope
-- **Architecture**: Evaluating trade-offs across approaches
-
-## Learn More
-
-- [MCP Sequential Thinking Server](https://github.com/modelcontextprotocol/servers/tree/main/src/sequentialthinking)
-- [Model Context Protocol](https://modelcontextprotocol.io/)
-- [Agent Skills Documentation](https://docs.claude.com/en/docs/agents-and-tools/agent-skills/overview.md)
-
-## License
-
-MIT

package/.agent/skills/sequential-thinking/SKILL.md

@@ -1,93 +0,0 @@
----
-name: sequential-thinking
-description: Use when complex problems require systematic step-by-step reasoning with ability to revise thoughts, branch into alternative approaches, or dynamically adjust scope. Ideal for multi-stage analysis, design planning, problem decomposition, or tasks with initially unclear scope.
-license: MIT
----
-
-# Sequential Thinking
-
-Enables structured problem-solving through iterative reasoning with revision and branching capabilities.
-
-## Core Capabilities
-
-- **Iterative reasoning**: Break complex problems into sequential thought steps
-- **Dynamic scope**: Adjust total thought count as understanding evolves
-- **Revision tracking**: Reconsider and modify previous conclusions
-- **Branch exploration**: Explore alternative reasoning paths from any point
-- **Maintained context**: Keep track of reasoning chain throughout analysis
-
-## When to Use
-
-Use `mcp__reasoning__sequentialthinking` when:
-- Problem requires multiple interconnected reasoning steps
-- Initial scope or approach is uncertain
-- Need to filter through complexity to find core issues
-- May need to backtrack or revise earlier conclusions
-- Want to explore alternative solution paths
-
-**Don't use for**: Simple queries, direct facts, or single-step tasks.
-
-## Basic Usage
-
-The MCP tool `mcp__reasoning__sequentialthinking` accepts these parameters:
-
-### Required Parameters
-
-- `thought` (string): Current reasoning step
-- `nextThoughtNeeded` (boolean): Whether more reasoning is needed
-- `thoughtNumber` (integer): Current step number (starts at 1)
-- `totalThoughts` (integer): Estimated total steps needed
-
-### Optional Parameters
-
-- `isRevision` (boolean): Indicates this revises previous thinking
-- `revisesThought` (integer): Which thought number is being reconsidered
-- `branchFromThought` (integer): Thought number to branch from
-- `branchId` (string): Identifier for this reasoning branch
-
-## Workflow Pattern
-
-```
-1. Start with initial thought (thoughtNumber: 1)
-2. For each step:
-   - Express current reasoning in `thought`
-   - Estimate remaining work via `totalThoughts` (adjust dynamically)
-   - Set `nextThoughtNeeded: true` to continue
-3. When reaching conclusion, set `nextThoughtNeeded: false`
-```
-
-## Simple Example
-
-```typescript
-// First thought
-{
-  thought: "Problem involves optimizing database queries. Need to identify bottlenecks first.",
-  thoughtNumber: 1,
-  totalThoughts: 5,
-  nextThoughtNeeded: true
-}
-
-// Second thought
-{
-  thought: "Analyzing query patterns reveals N+1 problem in user fetches.",
-  thoughtNumber: 2,
-  totalThoughts: 6, // Adjusted scope
-  nextThoughtNeeded: true
-}
-
-// ... continue until done
-```
-
-## Advanced Features
-
-For revision patterns, branching strategies, and complex workflows, see:
-- [Advanced Usage](references/advanced.md) - Revision and branching patterns
-- [Examples](references/examples.md) - Real-world use cases
-
-## Tips
-
-- Start with rough estimate for `totalThoughts`, refine as you progress
-- Use revision when assumptions prove incorrect
-- Branch when multiple approaches seem viable
-- Express uncertainty explicitly in thoughts
-- Adjust scope freely - accuracy matters less than progress visibility

package/.agent/skills/sequential-thinking/references/advanced.md

@@ -1,122 +0,0 @@
-# Advanced Usage: Revision and Branching
-
-## Revising Previous Thoughts
-
-When a thought proves incorrect or incomplete, use revision to correct the reasoning chain:
-
-```typescript
-{
-  thought: "Actually, the N+1 problem isn't the bottleneck—profiling shows the issue is missing indexes on join columns.",
-  thoughtNumber: 5,
-  totalThoughts: 7,
-  isRevision: true,
-  revisesThought: 2, // References thought #2
-  nextThoughtNeeded: true
-}
-```
-
-**When to revise**:
-- New evidence contradicts earlier conclusions
-- Assumptions prove incorrect
-- Scope was misunderstood
-- Need to correct factual errors
-
-## Branching Into Alternatives
-
-Explore different solution paths by branching from a specific thought:
-
-```typescript
-// Main path (thoughts 1-3)
-{
-  thought: "Could optimize with caching or database indexes.",
-  thoughtNumber: 3,
-  totalThoughts: 6,
-  nextThoughtNeeded: true
-}
-
-// Branch A: Explore caching
-{
-  thought: "If we implement Redis caching, we'd need to handle cache invalidation.",
-  thoughtNumber: 4,
-  totalThoughts: 6,
-  branchFromThought: 3,
-  branchId: "caching-approach",
-  nextThoughtNeeded: true
-}
-
-// Branch B: Explore indexing (alternative from thought 3)
-{
-  thought: "Adding composite index would avoid query overhead entirely.",
-  thoughtNumber: 4,
-  totalThoughts: 5,
-  branchFromThought: 3,
-  branchId: "indexing-approach",
-  nextThoughtNeeded: true
-}
-```
-
-**When to branch**:
-- Multiple viable approaches exist
-- Need to compare trade-offs
-- Exploring contingencies
-- Testing hypotheses in parallel
-
-## Combining Revision and Branching
-
-```typescript
-// Original branch proves problematic
-{
-  thought: "The caching approach has too many edge cases for our timeline.",
-  thoughtNumber: 6,
-  totalThoughts: 8,
-  branchId: "caching-approach",
-  isRevision: true,
-  revisesThought: 4,
-  nextThoughtNeeded: true
-}
-
-// Return to indexing branch
-{
-  thought: "Returning to index optimization—this approach is more reliable.",
-  thoughtNumber: 7,
-  totalThoughts: 9,
-  branchId: "indexing-approach",
-  nextThoughtNeeded: true
-}
-```
-
-## Dynamic Scope Adjustment
-
-Freely adjust `totalThoughts` as understanding evolves:
-
-```typescript
-// Initial estimate
-{ thoughtNumber: 1, totalThoughts: 5, ... }
-
-// Complexity increases
-{ thoughtNumber: 3, totalThoughts: 8, ... }
-
-// Actually simpler than expected
-{ thoughtNumber: 5, totalThoughts: 6, ... }
-```
-
-**Purpose**: Provide progress visibility, not strict planning. The estimate guides pacing but should adapt to reality.
-
-## Session Management
-
-Each reasoning session maintains its own context. The tool tracks:
-- All thoughts in sequence
-- Revision relationships
-- Branch hierarchies
-- Current state
-
-You don't need to manually manage state—focus on expressing reasoning clearly.
-
-## Best Practices
-
-1. **Express uncertainty**: "This might be...", "Uncertain if...", "Need to verify..."
-2. **Show reasoning**: Not just conclusions, but how you arrived there
-3. **Revise freely**: Correcting course is expected and valuable
-4. **Branch decisively**: When exploring alternatives, commit to exploring each fully
-5. **Adjust scope**: Don't lock into initial estimates
-6. **Maintain clarity**: Each thought should be self-contained enough to understand in isolation