cnhkmcp 2.1.9__py3-none-any.whl → 2.3.0__py3-none-any.whl

cnhkmcp/untracked/skills/brain-improve-alpha-performance/scripts/arxiv_api.py

@@ -0,0 +1,229 @@
+import requests
+import xml.etree.ElementTree as ET
+import os
+import sys
+import argparse
+
+def search_arxiv(query, max_results=10):
+    """Search arXiv for papers"""
+    base_url = "http://export.arxiv.org/api/query"
+    params = {
+        'search_query': query,
+        'start': 0,
+        'max_results': max_results
+    }
+    
+    response = requests.get(base_url, params=params)
+    return response.text
+
+def get_paper_metadata(paper_id):
+    """Get paper metadata directly from arXiv API"""
+    try:
+        # Use the arXiv API to get paper metadata
+        metadata_url = f"http://export.arxiv.org/api/query?id_list={paper_id}"
+        response = requests.get(metadata_url)
+        
+        if response.status_code == 200:
+            papers = parse_search_results(response.text)
+            if papers and len(papers) > 0:
+                return papers[0]
+        return None
+    except Exception as e:
+        print(f"Error fetching paper metadata: {e}")
+        return None
+
+def download_paper(paper_id, output_dir=".", paper_title=None):
+    """Download a paper by its ID and rename it to the paper title"""
+    pdf_url = f"https://arxiv.org/pdf/{paper_id}.pdf"
+    response = requests.get(pdf_url)
+    
+    if response.status_code == 200:
+        # Create filename from paper title if available, otherwise use paper ID
+        if paper_title:
+            # Clean the title for filename (remove special characters, limit length)
+            clean_title = "".join(c for c in paper_title if c.isalnum() or c in (' ', '-', '_')).rstrip()
+            clean_title = clean_title.replace(' ', '_')[:100]  # Limit length to 100 chars
+            filename = f"{clean_title}.pdf"
+        else:
+            filename = f"{paper_id}.pdf"
+        
+        filepath = os.path.join(output_dir, filename)
+        
+        with open(filepath, 'wb') as f:
+            f.write(response.content)
+        print(f"Downloaded: {filepath}")
+        return filepath
+    else:
+        print(f"Failed to download paper {paper_id}")
+        return None
+
+def parse_search_results(xml_content):
+    """Parse XML search results and extract paper information"""
+    try:
+        root = ET.fromstring(xml_content)
+        papers = []
+        
+        # Find all entry elements
+        for entry in root.findall('.//{http://www.w3.org/2005/Atom}entry'):
+            paper_info = {}
+            
+            # Extract title
+            title_elem = entry.find('.//{http://www.w3.org/2005/Atom}title')
+            if title_elem is not None:
+                paper_info['title'] = title_elem.text.strip()
+            
+            # Extract authors
+            authors = []
+            for author in entry.findall('.//{http://www.w3.org/2005/Atom}author'):
+                name_elem = author.find('.//{http://www.w3.org/2005/Atom}name')
+                if name_elem is not None:
+                    authors.append(name_elem.text.strip())
+            paper_info['authors'] = authors
+            
+            # Extract abstract
+            summary_elem = entry.find('.//{http://www.w3.org/2005/Atom}summary')
+            if summary_elem is not None:
+                paper_info['abstract'] = summary_elem.text.strip()
+            
+            # Extract paper ID from the id field
+            id_elem = entry.find('.//{http://www.w3.org/2005/Atom}id')
+            if id_elem is not None:
+                # Extract ID from URL like "http://arxiv.org/abs/2103.12345"
+                paper_id = id_elem.text.split('/')[-1]
+                paper_info['paper_id'] = paper_id
+            
+            # Extract published date
+            published_elem = entry.find('.//{http://www.w3.org/2005/Atom}published')
+            if published_elem is not None:
+                paper_info['published'] = published_elem.text.strip()
+            
+            papers.append(paper_info)
+        
+        return papers
+    except ET.ParseError as e:
+        print(f"Error parsing XML: {e}")
+        return []
+
+def search_and_download(query, max_results=5, download_first=False):
+    """Search for papers and optionally download the first result"""
+    print(f"Searching arXiv for: '{query}'")
+    print("-" * 50)
+    
+    # Search for papers
+    results = search_arxiv(query, max_results)
+    papers = parse_search_results(results)
+    
+    if not papers:
+        print("No papers found.")
+        return
+    
+    # Display search results
+    print(f"Found {len(papers)} papers:\n")
+    for i, paper in enumerate(papers, 1):
+        print(f"{i}. Title: {paper.get('title', 'N/A')}")
+        print(f"   Authors: {', '.join(paper.get('authors', ['N/A']))}")
+        print(f"   Paper ID: {paper.get('paper_id', 'N/A')}")
+        print(f"   Published: {paper.get('published', 'N/A')}")
+        print(f"   Abstract: {paper.get('abstract', 'N/A')[:200]}...")
+        print()
+    
+    # Optionally download first paper
+    if download_first and papers:
+        first_paper = papers[0]
+        paper_id = first_paper.get('paper_id')
+        paper_title = first_paper.get('title')
+        if paper_id:
+            print(f"Downloading first paper: {paper_id}")
+            download_paper(paper_id, paper_title=paper_title)
+        else:
+            print("Could not extract paper ID for download")
+
+def interactive_mode():
+    """Interactive mode for searching arXiv"""
+    print("🔍 arXiv Paper Search Tool")
+    print("=" * 40)
+    print("Commands:")
+    print("  search <query> [max_results] - Search for papers")
+    print("  download <paper_id> - Download a specific paper")
+    print("  help - Show this help message")
+    print("  quit/exit - Exit the program")
+    print()
+    
+    while True:
+        try:
+            command = input("📚 arxiv> ").strip()
+            
+            if not command:
+                continue
+                
+            parts = command.split()
+            cmd = parts[0].lower()
+            
+            if cmd in ['quit', 'exit', 'q']:
+                print("Goodbye! 👋")
+                break
+                
+            elif cmd == 'help':
+                print("Commands:")
+                print("  search <query> [max_results] - Search for papers")
+                print("  download <paper_id> - Download a specific paper")
+                print("  help - Show this help message")
+                print("  quit/exit - Exit the program")
+                print()
+                
+            elif cmd == 'search':
+                if len(parts) < 2:
+                    print("Usage: search <query> [max_results]")
+                    continue
+                    
+                query = ' '.join(parts[1:-1]) if len(parts) > 2 else parts[1]
+                max_results = int(parts[-1]) if len(parts) > 2 and parts[-1].isdigit() else 5
+                
+                search_and_download(query, max_results, download_first=False)
+                
+            elif cmd == 'download':
+                if len(parts) < 2:
+                    print("Usage: download <paper_id>")
+                    continue
+                    
+                paper_id = parts[1]
+                # Get paper metadata first
+                print(f"Fetching paper information for {paper_id}...")
+                paper_info = get_paper_metadata(paper_id)
+                
+                if paper_info and paper_info.get('title'):
+                    paper_title = paper_info['title']
+                    print(f"Found paper: {paper_title}")
+                    download_paper(paper_id, paper_title=paper_title)
+                else:
+                    print(f"Could not find paper information for {paper_id}")
+                    print("Downloading with paper ID as filename...")
+                    download_paper(paper_id)
+                
+            else:
+                print(f"Unknown command: {cmd}")
+                print("Type 'help' for available commands")
+                
+        except KeyboardInterrupt:
+            print("\nGoodbye! 👋")
+            break
+        except Exception as e:
+            print(f"Error: {e}")
+
+# Example usage
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='Search and download papers from arXiv')
+    parser.add_argument('query', nargs='?', help='Search query')
+    parser.add_argument('-n', '--max_results', type=int, default=5, help='Maximum number of results (default: 5)')
+    parser.add_argument('-d', '--download', action='store_true', help='Download the first result')
+    parser.add_argument('-i', '--interactive', action='store_true', help='Start interactive mode')
+    
+    args = parser.parse_args()
+    
+    if args.interactive:
+        interactive_mode()
+    elif args.query:
+        search_and_download(args.query, args.max_results, args.download)
+    else:
+        # Default behavior - start interactive mode
+        interactive_mode()

cnhkmcp/untracked/skills/planning-with-files/SKILL.md

@@ -0,0 +1,211 @@
+---
+name: planning-with-files
+version: "2.1.0"
+description: Implements Manus-style file-based planning for complex tasks. Creates task_plan.md, findings.md, and progress.md. Use when starting complex multi-step tasks, research projects, or any task requiring >5 tool calls.
+user-invocable: true
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - Glob
+  - Grep
+  - WebFetch
+  - WebSearch
+hooks:
+  SessionStart:
+    - hooks:
+        - type: command
+          command: "echo '[planning-with-files] Ready. Auto-activates for complex tasks, or invoke manually with /planning-with-files'"
+  PreToolUse:
+    - matcher: "Write|Edit|Bash"
+      hooks:
+        - type: command
+          command: "cat task_plan.md 2>/dev/null | head -30 || true"
+  PostToolUse:
+    - matcher: "Write|Edit"
+      hooks:
+        - type: command
+          command: "echo '[planning-with-files] File updated. If this completes a phase, update task_plan.md status.'"
+  Stop:
+    - hooks:
+        - type: command
+          command: "$HOME/.claude/skills/planning-with-files/scripts/check-complete.sh"
+---
+
+# Planning with Files
+
+Work like Manus: Use persistent markdown files as your "working memory on disk."
+
+## Important: Where Files Go
+
+When using this skill:
+
+- **Templates** are stored in the skill directory at `$HOME/.claude/skills/planning-with-files/templates/`
+- **Your planning files** (`task_plan.md`, `findings.md`, `progress.md`) should be created in **your project directory** — the folder where you're working
+
+| Location | What Goes There |
+|----------|-----------------|
+| Skill directory (`$HOME/.claude/skills/planning-with-files/`) | Templates, scripts, reference docs |
+| Your project directory | `task_plan.md`, `findings.md`, `progress.md` |
+
+This ensures your planning files live alongside your code, not buried in the skill installation folder.
+
+## Quick Start
+
+Before ANY complex task:
+
+1. **Create `task_plan.md`** in your project — Use [templates/task_plan.md](templates/task_plan.md) as reference
+2. **Create `findings.md`** in your project — Use [templates/findings.md](templates/findings.md) as reference
+3. **Create `progress.md`** in your project — Use [templates/progress.md](templates/progress.md) as reference
+4. **Re-read plan before decisions** — Refreshes goals in attention window
+5. **Update after each phase** — Mark complete, log errors
+
+> **Note:** All three planning files should be created in your current working directory (your project root), not in the skill's installation folder.
+
+## The Core Pattern
+
+```
+Context Window = RAM (volatile, limited)
+Filesystem = Disk (persistent, unlimited)
+
+→ Anything important gets written to disk.
+```
+
+## File Purposes
+
+| File | Purpose | When to Update |
+|------|---------|----------------|
+| `task_plan.md` | Phases, progress, decisions | After each phase |
+| `findings.md` | Research, discoveries | After ANY discovery |
+| `progress.md` | Session log, test results | Throughout session |
+
+## Critical Rules
+
+### 1. Create Plan First
+Never start a complex task without `task_plan.md`. Non-negotiable.
+
+### 2. The 2-Action Rule
+> "After every 2 view/browser/search operations, IMMEDIATELY save key findings to text files."
+
+This prevents visual/multimodal information from being lost.
+
+### 3. Read Before Decide
+Before major decisions, read the plan file. This keeps goals in your attention window.
+
+### 4. Update After Act
+After completing any phase:
+- Mark phase status: `in_progress` → `complete`
+- Log any errors encountered
+- Note files created/modified
+
+### 5. Log ALL Errors
+Every error goes in the plan file. This builds knowledge and prevents repetition.
+
+```markdown
+## Errors Encountered
+| Error | Attempt | Resolution |
+|-------|---------|------------|
+| FileNotFoundError | 1 | Created default config |
+| API timeout | 2 | Added retry logic |
+```
+
+### 6. Never Repeat Failures
+```
+if action_failed:
+    next_action != same_action
+```
+Track what you tried. Mutate the approach.
+
+## The 3-Strike Error Protocol
+
+```
+ATTEMPT 1: Diagnose & Fix
+  → Read error carefully
+  → Identify root cause
+  → Apply targeted fix
+
+ATTEMPT 2: Alternative Approach
+  → Same error? Try different method
+  → Different tool? Different library?
+  → NEVER repeat exact same failing action
+
+ATTEMPT 3: Broader Rethink
+  → Question assumptions
+  → Search for solutions
+  → Consider updating the plan
+
+AFTER 3 FAILURES: Escalate to User
+  → Explain what you tried
+  → Share the specific error
+  → Ask for guidance
+```
+
+## Read vs Write Decision Matrix
+
+| Situation | Action | Reason |
+|-----------|--------|--------|
+| Just wrote a file | DON'T read | Content still in context |
+| Viewed image/PDF | Write findings NOW | Multimodal → text before lost |
+| Browser returned data | Write to file | Screenshots don't persist |
+| Starting new phase | Read plan/findings | Re-orient if context stale |
+| Error occurred | Read relevant file | Need current state to fix |
+| Resuming after gap | Read all planning files | Recover state |
+
+## The 5-Question Reboot Test
+
+If you can answer these, your context management is solid:
+
+| Question | Answer Source |
+|----------|---------------|
+| Where am I? | Current phase in task_plan.md |
+| Where am I going? | Remaining phases |
+| What's the goal? | Goal statement in plan |
+| What have I learned? | findings.md |
+| What have I done? | progress.md |
+
+## When to Use This Pattern
+
+**Use for:**
+- Multi-step tasks (3+ steps)
+- Research tasks
+- Building/creating projects
+- Tasks spanning many tool calls
+- Anything requiring organization
+
+**Skip for:**
+- Simple questions
+- Single-file edits
+- Quick lookups
+
+## Templates
+
+Copy these templates to start:
+
+- [templates/task_plan.md](templates/task_plan.md) — Phase tracking
+- [templates/findings.md](templates/findings.md) — Research storage
+- [templates/progress.md](templates/progress.md) — Session logging
+
+## Scripts
+
+Helper scripts for automation:
+
+- `scripts/init-session.sh` — Initialize all planning files
+- `scripts/check-complete.sh` — Verify all phases complete
+
+## Advanced Topics
+
+- **Manus Principles:** See [reference.md](reference.md)
+- **Real Examples:** See [examples.md](examples.md)
+
+## Anti-Patterns
+
+| Don't | Do Instead |
+|-------|------------|
+| Use TodoWrite for persistence | Create task_plan.md file |
+| State goals once and forget | Re-read plan before decisions |
+| Hide errors and retry silently | Log errors to plan file |
+| Stuff everything in context | Store large content in files |
+| Start executing immediately | Create plan file FIRST |
+| Repeat failed actions | Track attempts, mutate approach |
+| Create files in skill directory | Create files in your project |

cnhkmcp/untracked/skills/planning-with-files/examples.md

@@ -0,0 +1,202 @@
+# Examples: Planning with Files in Action
+
+## Example 1: Research Task
+
+**User Request:** "Research the benefits of morning exercise and write a summary"
+
+### Loop 1: Create Plan
+```bash
+Write task_plan.md
+```
+
+```markdown
+# Task Plan: Morning Exercise Benefits Research
+
+## Goal
+Create a research summary on the benefits of morning exercise.
+
+## Phases
+- [ ] Phase 1: Create this plan ✓
+- [ ] Phase 2: Search and gather sources
+- [ ] Phase 3: Synthesize findings
+- [ ] Phase 4: Deliver summary
+
+## Key Questions
+1. What are the physical health benefits?
+2. What are the mental health benefits?
+3. What scientific studies support this?
+
+## Status
+**Currently in Phase 1** - Creating plan
+```
+
+### Loop 2: Research
+```bash
+Read task_plan.md           # Refresh goals
+WebSearch "morning exercise benefits"
+Write notes.md              # Store findings
+Edit task_plan.md           # Mark Phase 2 complete
+```
+
+### Loop 3: Synthesize
+```bash
+Read task_plan.md           # Refresh goals
+Read notes.md               # Get findings
+Write morning_exercise_summary.md
+Edit task_plan.md           # Mark Phase 3 complete
+```
+
+### Loop 4: Deliver
+```bash
+Read task_plan.md           # Verify complete
+Deliver morning_exercise_summary.md
+```
+
+---
+
+## Example 2: Bug Fix Task
+
+**User Request:** "Fix the login bug in the authentication module"
+
+### task_plan.md
+```markdown
+# Task Plan: Fix Login Bug
+
+## Goal
+Identify and fix the bug preventing successful login.
+
+## Phases
+- [x] Phase 1: Understand the bug report ✓
+- [x] Phase 2: Locate relevant code ✓
+- [ ] Phase 3: Identify root cause (CURRENT)
+- [ ] Phase 4: Implement fix
+- [ ] Phase 5: Test and verify
+
+## Key Questions
+1. What error message appears?
+2. Which file handles authentication?
+3. What changed recently?
+
+## Decisions Made
+- Auth handler is in src/auth/login.ts
+- Error occurs in validateToken() function
+
+## Errors Encountered
+- [Initial] TypeError: Cannot read property 'token' of undefined
+  → Root cause: user object not awaited properly
+
+## Status
+**Currently in Phase 3** - Found root cause, preparing fix
+```
+
+---
+
+## Example 3: Feature Development
+
+**User Request:** "Add a dark mode toggle to the settings page"
+
+### The 3-File Pattern in Action
+
+**task_plan.md:**
+```markdown
+# Task Plan: Dark Mode Toggle
+
+## Goal
+Add functional dark mode toggle to settings.
+
+## Phases
+- [x] Phase 1: Research existing theme system ✓
+- [x] Phase 2: Design implementation approach ✓
+- [ ] Phase 3: Implement toggle component (CURRENT)
+- [ ] Phase 4: Add theme switching logic
+- [ ] Phase 5: Test and polish
+
+## Decisions Made
+- Using CSS custom properties for theme
+- Storing preference in localStorage
+- Toggle component in SettingsPage.tsx
+
+## Status
+**Currently in Phase 3** - Building toggle component
+```
+
+**notes.md:**
+```markdown
+# Notes: Dark Mode Implementation
+
+## Existing Theme System
+- Located in: src/styles/theme.ts
+- Uses: CSS custom properties
+- Current themes: light only
+
+## Files to Modify
+1. src/styles/theme.ts - Add dark theme colors
+2. src/components/SettingsPage.tsx - Add toggle
+3. src/hooks/useTheme.ts - Create new hook
+4. src/App.tsx - Wrap with ThemeProvider
+
+## Color Decisions
+- Dark background: #1a1a2e
+- Dark surface: #16213e
+- Dark text: #eaeaea
+```
+
+**dark_mode_implementation.md:** (deliverable)
+```markdown
+# Dark Mode Implementation
+
+## Changes Made
+
+### 1. Added dark theme colors
+File: src/styles/theme.ts
+...
+
+### 2. Created useTheme hook
+File: src/hooks/useTheme.ts
+...
+```
+
+---
+
+## Example 4: Error Recovery Pattern
+
+When something fails, DON'T hide it:
+
+### Before (Wrong)
+```
+Action: Read config.json
+Error: File not found
+Action: Read config.json  # Silent retry
+Action: Read config.json  # Another retry
+```
+
+### After (Correct)
+```
+Action: Read config.json
+Error: File not found
+
+# Update task_plan.md:
+## Errors Encountered
+- config.json not found → Will create default config
+
+Action: Write config.json (default config)
+Action: Read config.json
+Success!
+```
+
+---
+
+## The Read-Before-Decide Pattern
+
+**Always read your plan before major decisions:**
+
+```
+[Many tool calls have happened...]
+[Context is getting long...]
+[Original goal might be forgotten...]
+
+→ Read task_plan.md          # This brings goals back into attention!
+→ Now make the decision       # Goals are fresh in context
+```
+
+This is why Manus can handle ~50 tool calls without losing track. The plan file acts as a "goal refresh" mechanism.