abelworkflow 0.1.0

package/skills/grok-search/scripts/groksearch_entry.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+"""Cross-platform bootstrap entrypoint for GrokSearch CLI."""
+
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from typing import Optional
+
+
+ROOT_DIR = Path(__file__).resolve().parent.parent
+VENV_DIR = Path(os.environ.get("GROKSEARCH_VENV_DIR", str(ROOT_DIR / ".venv")))
+REQ_FILE = ROOT_DIR / "requirements.txt"
+CLI_PY = ROOT_DIR / "scripts" / "groksearch_cli.py"
+
+
+def venv_python() -> Optional[Path]:
+    candidates = []
+    if sys.platform == "win32":
+        candidates.extend(
+            [
+                VENV_DIR / "Scripts" / "python.exe",
+                VENV_DIR / "Scripts" / "python",
+            ]
+        )
+    candidates.append(VENV_DIR / "bin" / "python")
+    for candidate in candidates:
+        if candidate.is_file():
+            return candidate
+    return None
+
+
+def python_spec() -> Optional[str]:
+    for name in ("GROKSEARCH_PYTHON", "AGENTS_SKILLS_PYTHON"):
+        value = os.environ.get(name)
+        if value:
+            return value
+    return None
+
+
+def has_uv() -> bool:
+    return shutil.which("uv") is not None
+
+
+def find_system_python() -> Optional[str]:
+    env_python = os.environ.get("AGENTS_SKILLS_PYTHON")
+    if env_python and Path(env_python).is_file():
+        return env_python
+    if sys.executable and Path(sys.executable).is_file():
+        return sys.executable
+    for command in ("python3", "python"):
+        found = shutil.which(command)
+        if found:
+            return found
+    return None
+
+
+def create_venv() -> None:
+    if has_uv():
+        command = ["uv", "venv"]
+        spec = python_spec()
+        if spec:
+            command.extend(["--python", spec])
+        command.append(str(VENV_DIR))
+        subprocess.run(command, check=True)
+        return
+    python_bin = find_system_python()
+    if not python_bin:
+        print("Error: No usable uv or python found. Cannot create virtual environment.", file=sys.stderr)
+        sys.exit(1)
+    subprocess.run([python_bin, "-m", "venv", str(VENV_DIR)], check=True)
+
+
+def install_deps(python_bin: Path) -> None:
+    check = subprocess.run(
+        [str(python_bin), "-c", "import httpx, tenacity"],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+    if check.returncode == 0:
+        return
+    if has_uv() and REQ_FILE.is_file():
+        subprocess.run(["uv", "pip", "install", "--python", str(python_bin), "-r", str(REQ_FILE)], check=True)
+        return
+    if REQ_FILE.is_file():
+        subprocess.run([str(python_bin), "-m", "pip", "install", "-r", str(REQ_FILE)], check=True)
+        return
+    subprocess.run([str(python_bin), "-m", "pip", "install", "httpx", "tenacity"], check=True)
+
+
+def validate_venv_dir() -> None:
+    if VENV_DIR.exists() and not VENV_DIR.is_dir():
+        print(f"Error: {VENV_DIR} exists but is not a directory.", file=sys.stderr)
+        sys.exit(1)
+    if VENV_DIR.is_dir() and not (VENV_DIR / "pyvenv.cfg").exists() and venv_python() is None:
+        print(f"Error: {VENV_DIR} exists but is not a valid venv.", file=sys.stderr)
+        sys.exit(1)
+
+
+def main() -> None:
+    validate_venv_dir()
+    python_bin = venv_python()
+    if python_bin is None:
+        create_venv()
+        python_bin = venv_python()
+        if python_bin is None:
+            print("Error: Failed to locate python in venv after creation.", file=sys.stderr)
+            sys.exit(1)
+    install_deps(python_bin)
+    result = subprocess.run([str(python_bin), str(CLI_PY)] + sys.argv[1:])
+    sys.exit(result.returncode)
+
+
+if __name__ == "__main__":
+    main()

package/skills/prompt-enhancer/ADVANCED.md

@@ -0,0 +1,74 @@
+# Advanced Usage
+
+## Using the Python Script Directly
+
+The `scripts/enhance.py` script can be used standalone:
+
+```bash
+# Basic usage
+python3 scripts/enhance.py "your prompt here"
+
+# With custom model (if API key is set)
+ANTHROPIC_API_KEY=sk-ant-... python3 scripts/enhance.py "your prompt"
+```
+
+## Environment Variables
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `ANTHROPIC_API_KEY` | Anthropic API key for Claude | - |
+| `OPENAI_API_KEY` | OpenAI API key (fallback) | - |
+| `PE_MODEL` | Model to use | `claude-sonnet-4-20250514` |
+
+## Integration with Other Tools
+
+### Piping Output
+
+```bash
+# Pipe to clipboard (macOS)
+python3 scripts/enhance.py "my prompt" | pbcopy
+
+# Pipe to file
+python3 scripts/enhance.py "my prompt" > enhanced.md
+
+# Chain with other commands
+python3 scripts/enhance.py "my prompt" | claude -p
+```
+
+### In Shell Scripts
+
+```bash
+#!/bin/bash
+ENHANCED=$(python3 ~/.agents/skills/prompt-enhancer/scripts/enhance.py "$1")
+echo "$ENHANCED"
+```
+
+## Manual Enhancement (No API)
+
+If no API key is available, you can manually apply the enhancement principles:
+
+1. Read the user's prompt
+2. Apply the template from [TEMPLATE.md](TEMPLATE.md)
+3. Structure the output with:
+   - Context section
+   - Objective section
+   - Step-by-step instructions
+   - Constraints
+
+## Troubleshooting
+
+### Script Not Found
+Ensure the skill is installed in the correct location:
+```bash
+ls ~/.agents/skills/prompt-enhancer/scripts/enhance.py
+```
+
+### Permission Denied
+Make the script executable:
+```bash
+chmod +x ~/.agents/skills/prompt-enhancer/scripts/enhance.py
+```
+
+### No API Key
+The script will fall back to a local template-based enhancement if no API key is found.
+

package/skills/prompt-enhancer/SKILL.md

@@ -0,0 +1,71 @@
+---
+name: prompt-enhancer
+description: Enhance and refine prompts for AI coding agents using Chain-of-Thought reasoning. Use when user asks to improve, optimize, rewrite, or enhance a prompt. Transforms vague requests into structured, high-context instructions for Claude Code, Codex, or Gemini CLI.
+allowed-tools: Bash(python3:*), Bash(pe:*), Read, Grep
+---
+
+# Prompt Enhancer Skill
+
+Transforms vague or simple prompts into structured, high-context instructions optimized for AI coding agents.
+
+## When to Use
+
+- User asks to "improve my prompt" or "make this prompt better"
+- User wants to "optimize this instruction for Claude/Codex"
+- User needs help writing a better prompt for an AI agent
+- User mentions "prompt engineering" or "rewrite this"
+
+## Quick Start
+
+Run the enhance script with the user's prompt:
+
+```bash
+python3 ~/.agents/skills/prompt-enhancer/scripts/enhance.py "user's raw prompt here"
+```
+
+## How It Works
+
+The enhancer applies these principles:
+
+1. **Add Context**: What project/tech stack is involved?
+2. **Clarify Objective**: What exactly should be accomplished?
+3. **Chain of Thought**: Add step-by-step reasoning instructions
+4. **Define Constraints**: What are the boundaries and requirements?
+5. **Specify Output**: What format should the result be in?
+
+## Output Format
+
+The enhanced prompt follows this structure:
+
+```markdown
+# Context
+[Refined context description]
+
+# Objective
+[Precise task definition]
+
+# Step-by-Step Instructions
+1. [Step 1]
+2. [Step 2]
+...
+
+# Constraints
+- [Constraint 1]
+- [Constraint 2]
+```
+
+## Additional Resources
+
+- For advanced usage patterns, see [ADVANCED.md](ADVANCED.md)
+- For the system prompt template, see [TEMPLATE.md](TEMPLATE.md)
+
+## Alternative: Use `pe` CLI
+
+If you have the `pe` CLI installed globally:
+
+```bash
+pe "user's raw prompt here"
+```
+
+Install via: `npm install -g prompt-enhancer` (or clone repo and `npm link`)
+

package/skills/prompt-enhancer/TEMPLATE.md

@@ -0,0 +1,91 @@
+# Prompt Enhancement Template
+
+This is the system prompt used to enhance user prompts.
+
+## System Role
+
+You are an expert Prompt Engineer for Coding Agents (Claude Code, Codex, Gemini CLI).
+Your goal is to rewrite the user's raw input into a structured, high-context prompt that maximizes the agent's effectiveness.
+
+## Guidelines
+
+1. **Structure**: Use a clear Markdown structure with headers.
+2. **Chain of Thought**: Explicitly ask the agent to "Think step-by-step" or "Analyze the file structure first".
+3. **Context**: If the user's prompt is vague, add placeholders like "[Insert relevant file(s)]" or "[Specify tech stack]" in the rewritten prompt, or simply infer them if obvious.
+4. **Format**:
+   - **Context**: What is the current state? What files are involved?
+   - **Objective**: What exactly should be done?
+   - **Constraints**: specific libraries, coding styles, or "no placeholders".
+   - **Response Format**: e.g., "Return only the code block" or "Explain step-by-step".
+
+## Output Template
+
+```markdown
+# Context
+[Refined context description]
+
+# Objective
+[Precise task definition]
+
+# Step-by-Step Instructions
+1. [Step 1]
+2. [Step 2]
+...
+
+# Constraints
+- [Constraint 1]
+- [Constraint 2]
+```
+
+## Examples
+
+### Example 1: Vague Input
+
+**Input:** "Write a login component"
+
+**Enhanced Output:**
+```markdown
+# Context
+Building a React application. Need secure authentication UI component.
+
+# Objective
+Create a functional Login component with form validation.
+
+# Step-by-Step Instructions
+1. Create LoginForm component with email/password fields
+2. Add client-side validation (email format, password min length)
+3. Handle form submission with loading state
+4. Display error messages for failed attempts
+5. Provide success callback for navigation
+
+# Constraints
+- Use controlled components for form inputs
+- Follow accessibility best practices (ARIA labels, focus management)
+- Handle both validation errors and API errors distinctly
+```
+
+### Example 2: Ambiguous Bug Fix
+
+**Input:** "fix the sorting bug"
+
+**Enhanced Output:**
+```markdown
+# Context
+There is a reported bug related to sorting functionality. Need to investigate and fix.
+
+# Objective
+Identify and fix the sorting bug in the codebase.
+
+# Step-by-Step Instructions
+1. First, identify files containing sorting logic (search for "sort", "order", "compare")
+2. Review the sorting implementation and identify the issue
+3. Check edge cases: empty arrays, single items, duplicate values
+4. Implement the fix with proper type handling
+5. Add or update tests to cover the bug scenario
+
+# Constraints
+- Maintain backward compatibility
+- Do not change the function signature unless necessary
+- Add inline comments explaining the fix
+```
+

package/skills/prompt-enhancer/scripts/enhance.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+"""
+Prompt Enhancer Script - Standalone Python script for enhancing prompts.
+Can be used with or without an API key.
+"""
+
+import sys
+import os
+import subprocess
+
+SYSTEM_PROMPT = """
+You are an expert Prompt Engineer for Coding Agents (Claude Code, Codex, Gemini CLI).
+Your goal is to rewrite the user's raw input into a structured, high-context prompt that maximizes the agent's effectiveness.
+
+Guidelines:
+1. Structure: Use a clear Markdown structure with headers.
+2. Chain of Thought: Explicitly ask the agent to "Think step-by-step" or "Analyze the file structure first".
+3. Context: If the user's prompt is vague, add placeholders like "[Insert relevant file(s)]" or "[Specify tech stack]" in the rewritten prompt, or simply infer them if obvious.
+4. Format:
+   - Context: What is the current state? What files are involved?
+   - Objective: What exactly should be done?
+   - Constraints: specific libraries, coding styles, or "no placeholders".
+   - Response Format: e.g., "Return only the code block" or "Explain step-by-step".
+
+Output Template:
+
+# Context
+[Refined context description]
+
+# Objective
+[Precise task definition]
+
+# Step-by-Step Instructions
+1. [Step 1]
+2. [Step 2]
+...
+
+# Constraints
+- [Constraint 1]
+- [Constraint 2]
+"""
+
+
+def enhance_with_anthropic(prompt: str, api_key: str) -> str:
+    """Enhance prompt using Anthropic API."""
+    try:
+        import anthropic
+    except ImportError:
+        print("Installing anthropic package...", file=sys.stderr)
+        subprocess.run(
+            [sys.executable, "-m", "pip", "install", "anthropic", "-q"],
+            check=True
+        )
+        import anthropic
+    
+    client = anthropic.Anthropic(api_key=api_key)
+    message = client.messages.create(
+        model=os.environ.get("PE_MODEL", "claude-sonnet-4-20250514"),
+        max_tokens=2048,
+        system=SYSTEM_PROMPT,
+        messages=[{"role": "user", "content": prompt}]
+    )
+    return message.content[0].text
+
+
+def enhance_with_openai(prompt: str, api_key: str) -> str:
+    """Enhance prompt using OpenAI API."""
+    try:
+        import openai
+    except ImportError:
+        print("Installing openai package...", file=sys.stderr)
+        subprocess.run(
+            [sys.executable, "-m", "pip", "install", "openai", "-q"],
+            check=True
+        )
+        import openai
+    
+    client = openai.OpenAI(api_key=api_key)
+    response = client.chat.completions.create(
+        model=os.environ.get("PE_MODEL", "gpt-4o"),
+        messages=[
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user", "content": prompt}
+        ]
+    )
+    return response.choices[0].message.content
+
+
+def enhance_locally(prompt: str) -> str:
+    """Enhance prompt using local template (no API)."""
+    return f"""# Context
+[Analyze the context for: {prompt}]
+
+# Objective
+{prompt}
+
+# Step-by-Step Instructions
+1. First, understand the current state and requirements
+2. Identify the key components involved
+3. Plan the implementation approach
+4. Execute the changes step by step
+5. Verify the results
+
+# Constraints
+- Follow existing code style and conventions
+- Ensure backward compatibility
+- Add appropriate error handling
+"""
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: enhance.py <prompt>", file=sys.stderr)
+        print("Example: enhance.py 'Write a login component'", file=sys.stderr)
+        sys.exit(1)
+    
+    prompt = " ".join(sys.argv[1:])
+    
+    # Try Anthropic first, then OpenAI, then local
+    anthropic_key = os.environ.get("ANTHROPIC_API_KEY")
+    openai_key = os.environ.get("OPENAI_API_KEY")
+    
+    try:
+        if anthropic_key:
+            result = enhance_with_anthropic(prompt, anthropic_key)
+        elif openai_key:
+            result = enhance_with_openai(prompt, openai_key)
+        else:
+            # No API key - use local template
+            print("Note: No API key found, using local template.", file=sys.stderr)
+            result = enhance_locally(prompt)
+        
+        print(result)
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        print("\nFalling back to local template...", file=sys.stderr)
+        print(enhance_locally(prompt))
+
+
+if __name__ == "__main__":
+    main()
+

package/skills/sequential-think/SKILL.md

@@ -0,0 +1,198 @@
+---
+name: sequential-think
+description: |
+  Multi-step reasoning engine for complex analysis and systematic problem solving. Use when: (1) Complex debugging scenarios with multiple layers, (2) Architectural analysis and system design, (3) Problems requiring hypothesis testing and validation, (4) Multi-component failure investigation, (5) Performance bottleneck identification. Triggers: "--think", "--think-hard", "--ultrathink", "analyze step by step", "break down this problem", "systematic analysis". IMPORTANT: Do NOT use for simple single-step tasks.
+---
+
+# Sequential Think
+
+Structured iterative thinking for complex problem-solving. Supports both MCP server and standalone CLI.
+
+## Execution Methods
+
+### Method 1: MCP Tools (if available)
+Use `mcp__sequential-thinking__sequentialthinking` tool directly.
+
+### Method 2: CLI Script (no MCP dependency)
+Run `scripts/sequential_think_cli.py` via Bash:
+
+```bash
+# Process a thought
+python scripts/sequential_think_cli.py think \
+  --thought "First, let me analyze the problem structure..." \
+  --thought-number 1 \
+  --total-thoughts 5
+
+# Continue thinking chain
+python scripts/sequential_think_cli.py think \
+  --thought "Based on step 1, I hypothesize that..." \
+  --thought-number 2 \
+  --total-thoughts 5
+
+# Revise a previous thought
+python scripts/sequential_think_cli.py think \
+  --thought "Reconsidering step 1, I realize..." \
+  --thought-number 3 \
+  --total-thoughts 5 \
+  --is-revision \
+  --revises-thought 1
+
+# Branch into alternative path
+python scripts/sequential_think_cli.py think \
+  --thought "Alternative approach: what if we..." \
+  --thought-number 4 \
+  --total-thoughts 6 \
+  --branch-from 2 \
+  --branch-id "alt-approach"
+
+# Final thought (complete chain)
+python scripts/sequential_think_cli.py think \
+  --thought "Conclusion: the solution is..." \
+  --thought-number 5 \
+  --total-thoughts 5 \
+  --no-next
+
+# View thought history
+python scripts/sequential_think_cli.py history [--format json|text]
+
+# Clear thought history
+python scripts/sequential_think_cli.py clear
+```
+
+## Core Principles
+
+### Iterative Thinking Process
+- Each tool call = one "thought" in the chain
+- Build upon, question, or revise previous thoughts
+- Express uncertainty when it exists
+
+### Dynamic Thought Count
+- Start with initial estimate of `totalThoughts`
+- Adjust up/down as understanding evolves
+- Add more thoughts even after reaching initial end
+
+### Hypothesis-Driven Approach
+1. Generate hypotheses as potential solutions emerge
+2. Verify hypotheses based on chain-of-thought steps
+3. Repeat until satisfied with solution
+
+### Completion Criteria
+- Only set `nextThoughtNeeded: false` when truly finished
+- Must have satisfactory, verified answer
+- Don't rush to conclusion
+
+## When to Use
+
+| Scenario | Use Sequential Think |
+|----------|---------------------|
+| Complex debugging (3+ layers) | ✅ Yes |
+| Architectural analysis | ✅ Yes |
+| Multi-component investigation | ✅ Yes |
+| Performance bottleneck analysis | ✅ Yes |
+| Root cause analysis | ✅ Yes |
+| Simple explanation | ❌ No |
+| Single-file change | ❌ No |
+| Straightforward fix | ❌ No |
+
+## Parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `thought` | string | Yes | Current thinking step content |
+| `thoughtNumber` | int | Yes | Current position in sequence (1-based) |
+| `totalThoughts` | int | Yes | Estimated total thoughts needed |
+| `nextThoughtNeeded` | bool | No | Whether more thinking needed (default: true) |
+| `isRevision` | bool | No | Whether this revises previous thinking |
+| `revisesThought` | int | No | Which thought number is being reconsidered |
+| `branchFromThought` | int | No | Branching point thought number |
+| `branchId` | string | No | Identifier for current branch |
+| `needsMoreThoughts` | bool | No | Signal that more thoughts needed beyond estimate |
+
+## Output Format
+
+```json
+{
+  "thoughtNumber": 3,
+  "totalThoughts": 5,
+  "nextThoughtNeeded": true,
+  "branches": ["alt-approach"],
+  "thoughtHistoryLength": 3
+}
+```
+
+## Workflow Pattern
+
+### Phase 1: Problem Decomposition
+```
+Thought 1: Identify problem scope and constraints
+Thought 2: Break into sub-problems
+Thought 3: Identify dependencies between sub-problems
+```
+
+### Phase 2: Hypothesis Generation
+```
+Thought 4: Generate initial hypothesis
+Thought 5: Identify evidence needed to verify
+```
+
+### Phase 3: Verification & Iteration
+```
+Thought 6: Test hypothesis against evidence
+Thought 7: Revise if needed (isRevision=true)
+Thought 8: Branch if alternative path promising
+```
+
+### Phase 4: Conclusion
+```
+Final Thought: Synthesize findings, provide answer (nextThoughtNeeded=false)
+```
+
+## Best Practices
+
+1. **Start with estimate, adjust as needed**
+   - Initial `totalThoughts` is just a guess
+   - Increase if problem more complex than expected
+   - Decrease if solution found early
+
+2. **Use revisions for course correction**
+   - Mark `isRevision=true` when reconsidering
+   - Reference `revisesThought` for clarity
+
+3. **Branch for alternative approaches**
+   - Use `branchFromThought` to explore alternatives
+   - Give meaningful `branchId` names
+
+4. **Filter irrelevant information**
+   - Each thought should advance toward solution
+   - Ignore tangential details
+
+5. **Don't rush completion**
+   - Only `nextThoughtNeeded=false` when truly done
+   - Verify hypothesis before concluding
+
+## Anti-Patterns
+
+| Prohibited | Correct |
+|------------|---------|
+| Use for simple tasks | Reserve for complex multi-step problems |
+| Skip thought numbers | Always increment correctly |
+| Conclude without verification | Verify hypothesis before final thought |
+| Ignore previous thoughts | Build upon or explicitly revise |
+| Fixed totalThoughts | Adjust as understanding evolves |
+
+## Integration with Other Tools
+
+### With augment-context-engine
+```
+augment-context-engine → align current state → Sequential Think → analyze and plan
+```
+
+### With Context7
+```
+Sequential Think → coordinate analysis → Context7 → provide official patterns
+```
+
+### With Serena
+```
+Serena → symbol-level exploration → Sequential Think → systematic analysis
+```

package/skills/sequential-think/scripts/.env.example

@@ -0,0 +1,5 @@
+# Sequential Think Configuration
+# This skill uses local storage only - no external API required.
+
+# Optional: Custom history file location (default: ~/.config/sequential-think/)
+# SEQUENTIAL_THINK_CONFIG_DIR=/path/to/custom/dir