abelworkflow 0.1.0 → 0.1.1

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

@@ -1,12 +1,13 @@
 #!/usr/bin/env python3
-"""
-Prompt Enhancer Script - Standalone Python script for enhancing prompts.
-Can be used with or without an API key.
-"""
+"""Prompt Enhancer CLI."""
 
-import sys
 import os
-import subprocess
+import sys
+
+from _dotenv import load_dotenv
+
+load_dotenv()
+
 
 SYSTEM_PROMPT = """
 You are an expert Prompt Engineer for Coding Agents (Claude Code, Codex, Gemini CLI).
@@ -41,21 +42,34 @@ Output Template:
 """
 
 
+def debug_enabled() -> bool:
+    """Return True when debug logging is explicitly enabled."""
+    value = os.environ.get("PE_DEBUG", "")
+    return value.strip().lower() in {"1", "true", "yes", "on"}
+
+
+def get_env_or_default(name: str, default: str) -> str:
+    """Return default when an env var is missing or blank."""
+    value = os.environ.get(name)
+    if value is None:
+        return default
+
+    value = value.strip()
+    return value or default
+
+
 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
-    
+        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=os.environ.get("PE_MODEL", "claude-sonnet-4-20250514"),
+        model=get_env_or_default("PE_MODEL", "claude-sonnet-4-20250514"),
         max_tokens=2048,
         system=SYSTEM_PROMPT,
         messages=[{"role": "user", "content": prompt}]
@@ -68,16 +82,13 @@ def enhance_with_openai(prompt: str, api_key: str) -> str:
     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
-    
+        raise RuntimeError(
+            "Missing dependency: openai. Install dependencies for the configured provider."
+        ) from None
+
     client = openai.OpenAI(api_key=api_key)
     response = client.chat.completions.create(
-        model=os.environ.get("PE_MODEL", "gpt-4o"),
+        model=get_env_or_default("PE_MODEL", "gpt-4o"),
         messages=[
             {"role": "system", "content": SYSTEM_PROMPT},
             {"role": "user", "content": prompt}
@@ -89,54 +100,53 @@ def enhance_with_openai(prompt: str, api_key: str) -> str:
 def enhance_locally(prompt: str) -> str:
     """Enhance prompt using local template (no API)."""
     return f"""# Context
-[Analyze the context for: {prompt}]
+[Add only the known repo, file, stack, or runtime context. If unknown, use placeholders like [files], [stack], or [environment].]
 
 # 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
+1. Restate the task precisely without changing the user's intent.
+2. Carry forward every explicit constraint from the original prompt.
+3. Add only the minimum missing execution context needed to act.
+4. If important details are unknown, leave placeholders instead of inventing requirements.
+5. Return the rewritten prompt in this structure.
 
 # Constraints
-- Follow existing code style and conventions
-- Ensure backward compatibility
-- Add appropriate error handling
+- Preserve the user's intent and explicit constraints.
+- Do not invent product, compatibility, or implementation requirements.
+- Keep the result concise, specific, and actionable for a coding agent.
 """
 
 
 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)
+        print("Usage: prompt_enhancer_entry.py <prompt>", file=sys.stderr)
+        print("Example: prompt_enhancer_entry.py 'Write a login component'", file=sys.stderr)
+        print("Environment: ANTHROPIC_API_KEY | OPENAI_API_KEY | PE_MODEL", 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)
+        if debug_enabled():
+            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/prompt-enhancer/scripts/prompt_enhancer_entry.py

@@ -0,0 +1,212 @@
+#!/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 required_modules() -> List[str]:
+    modules = []
+    if os.environ.get("ANTHROPIC_API_KEY"):
+        modules.append("anthropic")
+    if os.environ.get("OPENAI_API_KEY"):
+        modules.append("openai")
+    return modules
+
+
+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/context7-auto-research/.env

@@ -1,4 +0,0 @@
-# Context7 API Key Configuration
-# Get your API key from: https://context7.com/dashboard
-
-CONTEXT7_API_KEY=ctx7sk-d4d4d513-e3ae-44ae-b67d-30c046898ecf