abelworkflow 0.9.2 → 1.0.0

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

@@ -1,28 +0,0 @@
-"""Shared .env loader for Prompt Enhancer scripts."""
-
-import os
-from pathlib import Path
-
-
-def load_dotenv() -> bool:
-    env_path = Path(__file__).resolve().parent.parent / ".env"
-    if not env_path.exists():
-        return False
-    try:
-        with open(env_path, "r", encoding="utf-8") as f:
-            for line in f:
-                line = line.strip()
-                if not line or line.startswith("#") or "=" not in line:
-                    continue
-                key, _, value = line.partition("=")
-                key = key.strip()
-                value = value.strip()
-                if (value.startswith('"') and value.endswith('"')) or (
-                    value.startswith("'") and value.endswith("'")
-                ):
-                    value = value[1:-1]
-                if key and not os.environ.get(key):
-                    os.environ[key] = value
-        return True
-    except IOError:
-        return False

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

@@ -1,191 +0,0 @@
-#!/usr/bin/env python3
-"""Prompt Enhancer CLI for OpenAI-compatible endpoints."""
-
-import argparse
-import os
-import sys
-from typing import Tuple
-
-from _dotenv import load_dotenv
-
-load_dotenv()
-
-
-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 parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(
-        prog="prompt_enhancer_entry.py",
-        description="Enhance a prompt through a third-party OpenAI-compatible API.",
-    )
-    parser.add_argument("--url", dest="api_url", help="Third-party OpenAI-compatible base URL.")
-    parser.add_argument("--api-key", dest="api_key", help="Third-party OpenAI-compatible API key.")
-    parser.add_argument("--model", help="Model name on the third-party endpoint.")
-    parser.add_argument("--prompt", help="Prompt text to enhance.")
-    parser.add_argument("prompt_parts", nargs="*", help=argparse.SUPPRESS)
-    return parser.parse_args()
-
-
-def debug_enabled() -> bool:
-    value = os.environ.get("PE_DEBUG", "")
-    return value.strip().lower() in {"1", "true", "yes", "on"}
-
-
-def resolve_prompt(args: argparse.Namespace) -> str:
-    prompt = args.prompt.strip() if args.prompt else ""
-    if prompt:
-        return prompt
-    joined = " ".join(args.prompt_parts).strip()
-    if joined:
-        return joined
-    raise ValueError("Missing prompt. Pass --prompt \"...\" or a positional prompt.")
-
-
-def first_non_empty(*values: str) -> str:
-    for value in values:
-        stripped = value.strip()
-        if stripped:
-            return stripped
-    return ""
-
-
-def env_value(*names: str) -> str:
-    return first_non_empty(*(os.environ.get(name, "") for name in names))
-
-
-def resolve_config(args: argparse.Namespace) -> Tuple[str, str, str, str]:
-    api_url = (args.api_url or os.environ.get("PE_API_URL", "")).strip()
-    api_key = (args.api_key or os.environ.get("PE_API_KEY", "")).strip()
-    model = (args.model or os.environ.get("PE_MODEL", "")).strip()
-
-    missing = []
-    if not api_url:
-        missing.append("url")
-    if not api_key:
-        missing.append("apiKey")
-    if not model:
-        missing.append("model")
-    if missing:
-        has_openai_compatible_transport = bool(api_url or api_key)
-        if has_openai_compatible_transport:
-            raise ValueError(
-                "Missing third-party OpenAI-compatible config: "
-                + ", ".join(missing)
-                + ". If these fields are unavailable, use the current agent directly."
-            )
-
-        legacy_anthropic_key = env_value("ANTHROPIC_API_KEY")
-        if legacy_anthropic_key:
-            return "anthropic", "", legacy_anthropic_key, first_non_empty(model, "claude-sonnet-4-20250514")
-
-        legacy_openai_key = env_value("OPENAI_API_KEY")
-        if legacy_openai_key:
-            return "openai", "", legacy_openai_key, first_non_empty(model, "gpt-4o")
-
-        raise ValueError(
-            "Missing third-party OpenAI-compatible config: "
-            + ", ".join(missing)
-            + ". If these fields are unavailable, use the current agent directly."
-        )
-    return "openai-compatible", api_url, api_key, model
-
-
-def enhance_with_anthropic(prompt: str, api_key: str, model: str) -> str:
-    try:
-        import anthropic
-    except ImportError:
-        raise RuntimeError("Missing dependency: anthropic. Install dependencies for the configured provider.") from None
-
-    client = anthropic.Anthropic(api_key=api_key)
-    message = client.messages.create(
-        model=model,
-        max_tokens=2048,
-        system=SYSTEM_PROMPT,
-        messages=[{"role": "user", "content": prompt}],
-    )
-    return message.content[0].text
-
-
-def _extract_response_text(response) -> str:
-    content = response.choices[0].message.content
-    if isinstance(content, str):
-        return content
-    if content is None:
-        raise RuntimeError("The provider returned an empty response.")
-    return str(content)
-
-
-def enhance_with_openai(prompt: str, api_key: str, model: str, api_url: str = "") -> str:
-    try:
-        from openai import OpenAI
-    except ImportError:
-        raise RuntimeError("Missing dependency: openai. Install dependencies for the configured provider.") from None
-
-    kwargs = {"api_key": api_key}
-    if api_url:
-        kwargs["base_url"] = api_url
-    client = OpenAI(**kwargs)
-    response = client.chat.completions.create(
-        model=model,
-        messages=[
-            {"role": "system", "content": SYSTEM_PROMPT},
-            {"role": "user", "content": prompt},
-        ],
-    )
-    return _extract_response_text(response)
-
-
-def main() -> None:
-    try:
-        args = parse_args()
-        prompt = resolve_prompt(args)
-        provider, api_url, api_key, model = resolve_config(args)
-        if provider == "anthropic":
-            print(enhance_with_anthropic(prompt, api_key, model))
-        else:
-            print(enhance_with_openai(prompt, api_key, model, api_url))
-    except Exception as exc:
-        if debug_enabled():
-            print(f"Error: {exc}", file=sys.stderr)
-        else:
-            msg = str(exc)
-            if "Missing third-party OpenAI-compatible config" in msg:
-                print("Missing API configuration. Use the current agent directly instead, or set PE_API_URL, PE_API_KEY, PE_MODEL.", file=sys.stderr)
-            else:
-                print(msg, file=sys.stderr)
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()

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

@@ -1,253 +0,0 @@
-#!/usr/bin/env python3
-"""Cross-platform bootstrap entrypoint for Prompt Enhancer."""
-
-import os
-import re
-import shutil
-import subprocess
-import sys
-from pathlib import Path
-from typing import List, Optional
-
-from _dotenv import load_dotenv
-
-
-ROOT_DIR = Path(__file__).resolve().parent.parent
-REQ_FILE = ROOT_DIR / "requirements.txt"
-CLI_PY = ROOT_DIR / "scripts" / "enhance.py"
-
-
-def debug_enabled() -> bool:
-    value = os.environ.get("PE_DEBUG", "")
-    return value.strip().lower() in {"1", "true", "yes", "on"}
-
-
-def venv_dir() -> Path:
-    configured = os.environ.get("PROMPT_ENHANCER_VENV_DIR")
-    if not configured:
-        return ROOT_DIR / ".venv"
-    dir_path = Path(configured).expanduser()
-    if dir_path.is_absolute():
-        return dir_path
-    return ROOT_DIR / dir_path
-
-
-def venv_python() -> Optional[Path]:
-    dir_path = venv_dir()
-    candidates = []
-    if sys.platform == "win32":
-        candidates.extend(
-            [
-                dir_path / "Scripts" / "python.exe",
-                dir_path / "Scripts" / "python",
-            ]
-        )
-    candidates.append(dir_path / "bin" / "python")
-    for candidate in candidates:
-        if candidate.is_file():
-            return candidate
-    return None
-
-
-def python_spec() -> Optional[str]:
-    for name in ("PROMPT_ENHANCER_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:
-    dir_path = venv_dir()
-    if has_uv():
-        command = ["uv", "venv"]
-        spec = python_spec()
-        if spec:
-            command.extend(["--python", spec])
-        command.append(str(dir_path))
-        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(dir_path)], check=True)
-
-
-def first_non_empty(*values: str) -> str:
-    for value in values:
-        stripped = value.strip()
-        if stripped:
-            return stripped
-    return ""
-
-
-def env_value(*names: str) -> str:
-    return first_non_empty(*(os.environ.get(name, "") for name in names))
-
-
-def argv_value(flag: str, argv: Optional[List[str]] = None) -> str:
-    argv = sys.argv[1:] if argv is None else argv
-    for index, token in enumerate(argv):
-        if token == flag:
-            if index + 1 < len(argv):
-                return argv[index + 1].strip()
-            return ""
-        if token.startswith(f"{flag}="):
-            return token.split("=", 1)[1].strip()
-    return ""
-
-
-def resolved_provider(argv: Optional[List[str]] = None) -> Optional[str]:
-    argv = sys.argv[1:] if argv is None else argv
-    api_url = first_non_empty(argv_value("--url", argv), os.environ.get("PE_API_URL", ""))
-    api_key = first_non_empty(argv_value("--api-key", argv), os.environ.get("PE_API_KEY", ""))
-    model = first_non_empty(argv_value("--model", argv), os.environ.get("PE_MODEL", ""))
-
-    if api_url and api_key and model:
-        return "openai"
-    if api_url or api_key:
-        return None
-    if env_value("ANTHROPIC_API_KEY"):
-        return "anthropic"
-    if env_value("OPENAI_API_KEY"):
-        return "openai"
-    return None
-
-
-def required_modules() -> List[str]:
-    provider = resolved_provider()
-    if provider == "anthropic":
-        return ["anthropic"]
-    if provider == "openai":
-        return ["openai"]
-    return []
-
-
-def install_targets(modules: List[str]) -> List[str]:
-    if not REQ_FILE.is_file():
-        return modules
-
-    requirements = {}
-    for raw_line in REQ_FILE.read_text(encoding="utf-8").splitlines():
-        line = raw_line.split("#", 1)[0].strip()
-        if not line:
-            continue
-        package = re.split(r"[<>=!~\\[; ]", line, maxsplit=1)[0].strip().lower()
-        if package:
-            requirements[package] = line
-
-    return [requirements.get(module.lower(), module) for module in modules]
-
-
-def has_required_modules(python_bin: str, modules: List[str]) -> bool:
-    if not modules:
-        return True
-    check = subprocess.run(
-        [python_bin, "-c", "; ".join(f"import {module}" for module in modules)],
-        stdout=subprocess.DEVNULL,
-        stderr=subprocess.DEVNULL,
-    )
-    return check.returncode == 0
-
-
-def install_deps(python_bin: Path, modules: Optional[List[str]] = None) -> None:
-    modules = required_modules() if modules is None else modules
-    if not modules:
-        return
-    targets = install_targets(modules)
-    if has_required_modules(str(python_bin), modules):
-        return
-    try:
-        kwargs = {
-            "check": True,
-            "stdout": subprocess.DEVNULL,
-            "stderr": subprocess.PIPE,
-            "text": True,
-        }
-        if has_uv():
-            subprocess.run(["uv", "pip", "install", "--python", str(python_bin), *targets], **kwargs)
-            return
-        subprocess.run([str(python_bin), "-m", "pip", "install", *targets], **kwargs)
-    except subprocess.CalledProcessError as exc:
-        if debug_enabled():
-            details = (exc.stderr or "").strip()
-            if details:
-                print(details, file=sys.stderr)
-            print(
-                "Warning: Failed to install prompt enhancer dependencies; continuing with existing environment.",
-                file=sys.stderr,
-            )
-
-
-def validate_venv_dir() -> None:
-    dir_path = venv_dir()
-    if dir_path.exists() and not dir_path.is_dir():
-        print(f"Error: {dir_path} exists but is not a directory.", file=sys.stderr)
-        sys.exit(1)
-    if dir_path.is_dir() and not (dir_path / "pyvenv.cfg").exists() and venv_python() is None:
-        print(f"Error: {dir_path} exists but is not a valid venv.", file=sys.stderr)
-        sys.exit(1)
-
-
-def should_passthrough_cli() -> bool:
-    return len(sys.argv) < 2
-
-
-def passthrough_python() -> Optional[str]:
-    if sys.executable and Path(sys.executable).is_file():
-        return sys.executable
-    return find_system_python()
-
-
-def runtime_python() -> str:
-    modules = required_modules()
-    current_python = passthrough_python()
-    if current_python and has_required_modules(current_python, modules):
-        return current_python
-
-    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, modules)
-    return str(python_bin)
-
-
-def main() -> None:
-    if should_passthrough_cli():
-        python_bin = passthrough_python()
-        if not python_bin:
-            print("Error: No usable python found for CLI usage output.", file=sys.stderr)
-            sys.exit(1)
-        result = subprocess.run([python_bin, str(CLI_PY)] + sys.argv[1:])
-        sys.exit(result.returncode)
-    load_dotenv()
-    python_bin = runtime_python()
-    result = subprocess.run([python_bin, str(CLI_PY)] + sys.argv[1:])
-    sys.exit(result.returncode)
-
-
-if __name__ == "__main__":
-    main()

package/skills/sequential-think/SKILL.md

@@ -1,198 +0,0 @@
----
-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

@@ -1,5 +0,0 @@
-# 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