@funnycode/myclaude 0.1.76 → 0.1.78

package/seed/marketplaces/ecc/skills/skill-comply/scripts/runner.py

@@ -1,186 +1,186 @@
-"""Run scenarios via claude -p and parse tool calls from stream-json output."""
-
-from __future__ import annotations
-
-import json
-import re
-import shlex
-import shutil
-import subprocess
-from dataclasses import dataclass
-from pathlib import Path
-
-from scripts.parser import ObservationEvent
-from scripts.scenario_generator import Scenario
-
-SANDBOX_BASE = Path("/tmp/skill-comply-sandbox")
-ALLOWED_MODELS = frozenset({"haiku", "sonnet", "opus"})
-# Shell builtins cannot be invoked via subprocess.run; cwd is already
-# controlled by the cwd= keyword. Scenarios that include these in
-# setup_commands (a common shell-style convention) must be tolerated.
-SHELL_BUILTINS = frozenset({"cd", "pushd", "popd"})
-
-
-@dataclass(frozen=True)
-class ScenarioRun:
-    scenario: Scenario
-    observations: tuple[ObservationEvent, ...]
-    sandbox_dir: Path
-
-
-def run_scenario(
-    scenario: Scenario,
-    model: str = "sonnet",
-    max_turns: int = 30,
-    timeout: int = 300,
-) -> ScenarioRun:
-    """Execute a scenario and extract tool calls from stream-json output."""
-    if model not in ALLOWED_MODELS:
-        raise ValueError(f"Unknown model: {model!r}. Allowed: {ALLOWED_MODELS}")
-
-    sandbox_dir = _safe_sandbox_dir(scenario.id)
-    _setup_sandbox(sandbox_dir, scenario)
-
-    result = subprocess.run(
-        [
-            "claude", "-p", scenario.prompt,
-            "--model", model,
-            "--max-turns", str(max_turns),
-            "--add-dir", str(sandbox_dir),
-            "--allowedTools", "Read,Write,Edit,Bash,Glob,Grep",
-            "--output-format", "stream-json",
-            "--verbose",
-        ],
-        capture_output=True,
-        text=True,
-        timeout=timeout,
-        cwd=sandbox_dir,
-    )
-
-    # claude -p returns rc=1 when --max-turns is reached, but the stream-json
-    # output is still complete and parseable. Treat this graceful termination
-    # as non-fatal so scenarios that hit the turn cap still produce usable
-    # observations.
-    nonfatal_max_turns = (
-        result.returncode == 1
-        and '"terminal_reason":"max_turns"' in result.stdout
-    )
-    if result.returncode != 0 and not nonfatal_max_turns:
-        # Include both stderr and stdout tails. claude -p often surfaces the
-        # actual failure context (model error JSON, partial stream-json) on
-        # stdout, while stderr carries generic transport / auth messages.
-        # Showing both dramatically reduces "rc=N: <empty>" debugging dead-ends.
-        raise RuntimeError(
-            f"claude -p failed (rc={result.returncode}): "
-            f"stderr={result.stderr[:500]!r} stdout_tail={result.stdout[-500:]!r}"
-        )
-
-    observations = _parse_stream_json(result.stdout)
-
-    return ScenarioRun(
-        scenario=scenario,
-        observations=tuple(observations),
-        sandbox_dir=sandbox_dir,
-    )
-
-
-def _safe_sandbox_dir(scenario_id: str) -> Path:
-    """Sanitize scenario ID and ensure path stays within sandbox base."""
-    safe_id = re.sub(r"[^a-zA-Z0-9\-_]", "_", scenario_id)
-    path = SANDBOX_BASE / safe_id
-    # Validate path stays within sandbox base (raises ValueError on traversal)
-    path.resolve().relative_to(SANDBOX_BASE.resolve())
-    return path
-
-
-def _setup_sandbox(sandbox_dir: Path, scenario: Scenario) -> None:
-    """Create sandbox directory and run setup commands."""
-    if sandbox_dir.exists():
-        shutil.rmtree(sandbox_dir)
-    sandbox_dir.mkdir(parents=True)
-
-    subprocess.run(["git", "init"], cwd=sandbox_dir, capture_output=True)
-
-    for cmd in scenario.setup_commands:
-        parts = shlex.split(cmd)
-        if not parts or parts[0] in SHELL_BUILTINS:
-            # Shell builtins (cd/pushd/popd) cannot run as subprocess; skip.
-            continue
-        try:
-            subprocess.run(parts, cwd=sandbox_dir, capture_output=True)
-        except FileNotFoundError:
-            # Setup tool not installed in this environment; skip rather than
-            # crash the whole scenario. The compliance run continues.
-            continue
-
-
-def _parse_stream_json(stdout: str) -> list[ObservationEvent]:
-    """Parse claude -p stream-json output into ObservationEvents.
-
-    Stream-json format:
-    - type=assistant with content[].type=tool_use → tool call (name, input)
-    - type=user with content[].type=tool_result → tool result (output)
-    """
-    events: list[ObservationEvent] = []
-    pending: dict[str, dict] = {}
-    event_counter = 0
-
-    for line in stdout.strip().splitlines():
-        try:
-            msg = json.loads(line)
-        except json.JSONDecodeError:
-            continue
-
-        msg_type = msg.get("type")
-
-        if msg_type == "assistant":
-            content = msg.get("message", {}).get("content", [])
-            for block in content:
-                if block.get("type") == "tool_use":
-                    tool_use_id = block.get("id", "")
-                    tool_input = block.get("input", {})
-                    input_str = (
-                        json.dumps(tool_input)[:5000]
-                        if isinstance(tool_input, dict)
-                        else str(tool_input)[:5000]
-                    )
-                    pending[tool_use_id] = {
-                        "tool": block.get("name", "unknown"),
-                        "input": input_str,
-                        "order": event_counter,
-                    }
-                    event_counter += 1
-
-        elif msg_type == "user":
-            content = msg.get("message", {}).get("content", [])
-            if isinstance(content, list):
-                for block in content:
-                    tool_use_id = block.get("tool_use_id", "")
-                    if tool_use_id in pending:
-                        info = pending.pop(tool_use_id)
-                        output_content = block.get("content", "")
-                        if isinstance(output_content, list):
-                            output_str = json.dumps(output_content)[:5000]
-                        else:
-                            output_str = str(output_content)[:5000]
-
-                        events.append(ObservationEvent(
-                            timestamp=f"T{info['order']:04d}",
-                            event="tool_complete",
-                            tool=info["tool"],
-                            session=msg.get("session_id", "unknown"),
-                            input=info["input"],
-                            output=output_str,
-                        ))
-
-    for _tool_use_id, info in pending.items():
-        events.append(ObservationEvent(
-            timestamp=f"T{info['order']:04d}",
-            event="tool_complete",
-            tool=info["tool"],
-            session="unknown",
-            input=info["input"],
-            output="",
-        ))
-
-    return sorted(events, key=lambda e: e.timestamp)
+"""Run scenarios via claude -p and parse tool calls from stream-json output."""
+
+from __future__ import annotations
+
+import json
+import re
+import shlex
+import shutil
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+from scripts.parser import ObservationEvent
+from scripts.scenario_generator import Scenario
+
+SANDBOX_BASE = Path("/tmp/skill-comply-sandbox")
+ALLOWED_MODELS = frozenset({"haiku", "sonnet", "opus"})
+# Shell builtins cannot be invoked via subprocess.run; cwd is already
+# controlled by the cwd= keyword. Scenarios that include these in
+# setup_commands (a common shell-style convention) must be tolerated.
+SHELL_BUILTINS = frozenset({"cd", "pushd", "popd"})
+
+
+@dataclass(frozen=True)
+class ScenarioRun:
+    scenario: Scenario
+    observations: tuple[ObservationEvent, ...]
+    sandbox_dir: Path
+
+
+def run_scenario(
+    scenario: Scenario,
+    model: str = "sonnet",
+    max_turns: int = 30,
+    timeout: int = 300,
+) -> ScenarioRun:
+    """Execute a scenario and extract tool calls from stream-json output."""
+    if model not in ALLOWED_MODELS:
+        raise ValueError(f"Unknown model: {model!r}. Allowed: {ALLOWED_MODELS}")
+
+    sandbox_dir = _safe_sandbox_dir(scenario.id)
+    _setup_sandbox(sandbox_dir, scenario)
+
+    result = subprocess.run(
+        [
+            "claude", "-p", scenario.prompt,
+            "--model", model,
+            "--max-turns", str(max_turns),
+            "--add-dir", str(sandbox_dir),
+            "--allowedTools", "Read,Write,Edit,Bash,Glob,Grep",
+            "--output-format", "stream-json",
+            "--verbose",
+        ],
+        capture_output=True,
+        text=True,
+        timeout=timeout,
+        cwd=sandbox_dir,
+    )
+
+    # claude -p returns rc=1 when --max-turns is reached, but the stream-json
+    # output is still complete and parseable. Treat this graceful termination
+    # as non-fatal so scenarios that hit the turn cap still produce usable
+    # observations.
+    nonfatal_max_turns = (
+        result.returncode == 1
+        and '"terminal_reason":"max_turns"' in result.stdout
+    )
+    if result.returncode != 0 and not nonfatal_max_turns:
+        # Include both stderr and stdout tails. claude -p often surfaces the
+        # actual failure context (model error JSON, partial stream-json) on
+        # stdout, while stderr carries generic transport / auth messages.
+        # Showing both dramatically reduces "rc=N: <empty>" debugging dead-ends.
+        raise RuntimeError(
+            f"claude -p failed (rc={result.returncode}): "
+            f"stderr={result.stderr[:500]!r} stdout_tail={result.stdout[-500:]!r}"
+        )
+
+    observations = _parse_stream_json(result.stdout)
+
+    return ScenarioRun(
+        scenario=scenario,
+        observations=tuple(observations),
+        sandbox_dir=sandbox_dir,
+    )
+
+
+def _safe_sandbox_dir(scenario_id: str) -> Path:
+    """Sanitize scenario ID and ensure path stays within sandbox base."""
+    safe_id = re.sub(r"[^a-zA-Z0-9\-_]", "_", scenario_id)
+    path = SANDBOX_BASE / safe_id
+    # Validate path stays within sandbox base (raises ValueError on traversal)
+    path.resolve().relative_to(SANDBOX_BASE.resolve())
+    return path
+
+
+def _setup_sandbox(sandbox_dir: Path, scenario: Scenario) -> None:
+    """Create sandbox directory and run setup commands."""
+    if sandbox_dir.exists():
+        shutil.rmtree(sandbox_dir)
+    sandbox_dir.mkdir(parents=True)
+
+    subprocess.run(["git", "init"], cwd=sandbox_dir, capture_output=True)
+
+    for cmd in scenario.setup_commands:
+        parts = shlex.split(cmd)
+        if not parts or parts[0] in SHELL_BUILTINS:
+            # Shell builtins (cd/pushd/popd) cannot run as subprocess; skip.
+            continue
+        try:
+            subprocess.run(parts, cwd=sandbox_dir, capture_output=True)
+        except FileNotFoundError:
+            # Setup tool not installed in this environment; skip rather than
+            # crash the whole scenario. The compliance run continues.
+            continue
+
+
+def _parse_stream_json(stdout: str) -> list[ObservationEvent]:
+    """Parse claude -p stream-json output into ObservationEvents.
+
+    Stream-json format:
+    - type=assistant with content[].type=tool_use → tool call (name, input)
+    - type=user with content[].type=tool_result → tool result (output)
+    """
+    events: list[ObservationEvent] = []
+    pending: dict[str, dict] = {}
+    event_counter = 0
+
+    for line in stdout.strip().splitlines():
+        try:
+            msg = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+
+        msg_type = msg.get("type")
+
+        if msg_type == "assistant":
+            content = msg.get("message", {}).get("content", [])
+            for block in content:
+                if block.get("type") == "tool_use":
+                    tool_use_id = block.get("id", "")
+                    tool_input = block.get("input", {})
+                    input_str = (
+                        json.dumps(tool_input)[:5000]
+                        if isinstance(tool_input, dict)
+                        else str(tool_input)[:5000]
+                    )
+                    pending[tool_use_id] = {
+                        "tool": block.get("name", "unknown"),
+                        "input": input_str,
+                        "order": event_counter,
+                    }
+                    event_counter += 1
+
+        elif msg_type == "user":
+            content = msg.get("message", {}).get("content", [])
+            if isinstance(content, list):
+                for block in content:
+                    tool_use_id = block.get("tool_use_id", "")
+                    if tool_use_id in pending:
+                        info = pending.pop(tool_use_id)
+                        output_content = block.get("content", "")
+                        if isinstance(output_content, list):
+                            output_str = json.dumps(output_content)[:5000]
+                        else:
+                            output_str = str(output_content)[:5000]
+
+                        events.append(ObservationEvent(
+                            timestamp=f"T{info['order']:04d}",
+                            event="tool_complete",
+                            tool=info["tool"],
+                            session=msg.get("session_id", "unknown"),
+                            input=info["input"],
+                            output=output_str,
+                        ))
+
+    for _tool_use_id, info in pending.items():
+        events.append(ObservationEvent(
+            timestamp=f"T{info['order']:04d}",
+            event="tool_complete",
+            tool=info["tool"],
+            session="unknown",
+            input=info["input"],
+            output="",
+        ))
+
+    return sorted(events, key=lambda e: e.timestamp)

package/seed/marketplaces/ecc/skills/skill-comply/scripts/scenario_generator.py

@@ -1,70 +1,70 @@
-"""Generate pressure scenarios from skill + spec using LLM."""
-
-from __future__ import annotations
-
-import subprocess
-from dataclasses import dataclass
-from pathlib import Path
-
-import yaml
-
-from scripts.utils import extract_yaml
-
-PROMPTS_DIR = Path(__file__).parent.parent / "prompts"
-
-
-@dataclass(frozen=True)
-class Scenario:
-    id: str
-    level: int
-    level_name: str
-    description: str
-    prompt: str
-    setup_commands: tuple[str, ...]
-
-
-def generate_scenarios(
-    skill_path: Path,
-    spec_yaml: str,
-    model: str = "haiku",
-) -> list[Scenario]:
-    """Generate 3 scenarios with decreasing prompt strictness.
-
-    Calls claude -p with the scenario_generator prompt, parses YAML output.
-    """
-    skill_content = skill_path.read_text()
-    prompt_template = (PROMPTS_DIR / "scenario_generator.md").read_text()
-    prompt = (
-        prompt_template
-        .replace("{skill_content}", skill_content)
-        .replace("{spec_yaml}", spec_yaml)
-    )
-
-    result = subprocess.run(
-        ["claude", "-p", prompt, "--model", model, "--output-format", "text"],
-        capture_output=True,
-        text=True,
-        timeout=120,
-    )
-
-    if result.returncode != 0:
-        raise RuntimeError(f"claude -p failed: {result.stderr}")
-
-    if not result.stdout.strip():
-        raise RuntimeError("claude -p returned empty output")
-
-    raw_yaml = extract_yaml(result.stdout)
-    parsed = yaml.safe_load(raw_yaml)
-
-    scenarios: list[Scenario] = []
-    for s in parsed["scenarios"]:
-        scenarios.append(Scenario(
-            id=s["id"],
-            level=s["level"],
-            level_name=s["level_name"],
-            description=s["description"],
-            prompt=s["prompt"].strip(),
-            setup_commands=tuple(s.get("setup_commands", [])),
-        ))
-
-    return sorted(scenarios, key=lambda s: s.level)
+"""Generate pressure scenarios from skill + spec using LLM."""
+
+from __future__ import annotations
+
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+import yaml
+
+from scripts.utils import extract_yaml
+
+PROMPTS_DIR = Path(__file__).parent.parent / "prompts"
+
+
+@dataclass(frozen=True)
+class Scenario:
+    id: str
+    level: int
+    level_name: str
+    description: str
+    prompt: str
+    setup_commands: tuple[str, ...]
+
+
+def generate_scenarios(
+    skill_path: Path,
+    spec_yaml: str,
+    model: str = "haiku",
+) -> list[Scenario]:
+    """Generate 3 scenarios with decreasing prompt strictness.
+
+    Calls claude -p with the scenario_generator prompt, parses YAML output.
+    """
+    skill_content = skill_path.read_text()
+    prompt_template = (PROMPTS_DIR / "scenario_generator.md").read_text()
+    prompt = (
+        prompt_template
+        .replace("{skill_content}", skill_content)
+        .replace("{spec_yaml}", spec_yaml)
+    )
+
+    result = subprocess.run(
+        ["claude", "-p", prompt, "--model", model, "--output-format", "text"],
+        capture_output=True,
+        text=True,
+        timeout=120,
+    )
+
+    if result.returncode != 0:
+        raise RuntimeError(f"claude -p failed: {result.stderr}")
+
+    if not result.stdout.strip():
+        raise RuntimeError("claude -p returned empty output")
+
+    raw_yaml = extract_yaml(result.stdout)
+    parsed = yaml.safe_load(raw_yaml)
+
+    scenarios: list[Scenario] = []
+    for s in parsed["scenarios"]:
+        scenarios.append(Scenario(
+            id=s["id"],
+            level=s["level"],
+            level_name=s["level_name"],
+            description=s["description"],
+            prompt=s["prompt"].strip(),
+            setup_commands=tuple(s.get("setup_commands", [])),
+        ))
+
+    return sorted(scenarios, key=lambda s: s.level)

package/seed/marketplaces/ecc/skills/skill-comply/scripts/spec_generator.py

@@ -1,72 +1,72 @@
-"""Generate compliance specs from skill files using LLM."""
-
-from __future__ import annotations
-
-import subprocess
-import tempfile
-from pathlib import Path
-
-import yaml
-
-from scripts.parser import ComplianceSpec, parse_spec
-from scripts.utils import extract_yaml
-
-PROMPTS_DIR = Path(__file__).parent.parent / "prompts"
-
-
-def generate_spec(
-    skill_path: Path,
-    model: str = "haiku",
-    max_retries: int = 2,
-) -> ComplianceSpec:
-    """Generate a compliance spec from a skill/rule file.
-
-    Calls claude -p with the spec_generator prompt, parses YAML output.
-    Retries on YAML parse errors with error feedback.
-    """
-    skill_content = skill_path.read_text()
-    prompt_template = (PROMPTS_DIR / "spec_generator.md").read_text()
-    base_prompt = prompt_template.replace("{skill_content}", skill_content)
-
-    last_error: Exception | None = None
-
-    for attempt in range(max_retries + 1):
-        prompt = base_prompt
-        if attempt > 0 and last_error is not None:
-            prompt += (
-                f"\n\nPREVIOUS ATTEMPT FAILED with YAML parse error:\n"
-                f"{last_error}\n\n"
-                f"Please fix the YAML. Remember to quote all string values "
-                f"that contain colons, e.g.: description: \"Use type: description format\""
-            )
-
-        result = subprocess.run(
-            ["claude", "-p", prompt, "--model", model, "--output-format", "text"],
-            capture_output=True,
-            text=True,
-            timeout=120,
-        )
-
-        if result.returncode != 0:
-            raise RuntimeError(f"claude -p failed: {result.stderr}")
-
-        raw_yaml = extract_yaml(result.stdout)
-
-        tmp_path = None
-        with tempfile.NamedTemporaryFile(
-            mode="w", suffix=".yaml", delete=False,
-        ) as f:
-            f.write(raw_yaml)
-            tmp_path = Path(f.name)
-
-        try:
-            return parse_spec(tmp_path)
-        except (yaml.YAMLError, KeyError, TypeError) as e:
-            last_error = e
-            if attempt == max_retries:
-                raise
-        finally:
-            if tmp_path is not None:
-                tmp_path.unlink(missing_ok=True)
-
-    raise RuntimeError("unreachable")
+"""Generate compliance specs from skill files using LLM."""
+
+from __future__ import annotations
+
+import subprocess
+import tempfile
+from pathlib import Path
+
+import yaml
+
+from scripts.parser import ComplianceSpec, parse_spec
+from scripts.utils import extract_yaml
+
+PROMPTS_DIR = Path(__file__).parent.parent / "prompts"
+
+
+def generate_spec(
+    skill_path: Path,
+    model: str = "haiku",
+    max_retries: int = 2,
+) -> ComplianceSpec:
+    """Generate a compliance spec from a skill/rule file.
+
+    Calls claude -p with the spec_generator prompt, parses YAML output.
+    Retries on YAML parse errors with error feedback.
+    """
+    skill_content = skill_path.read_text()
+    prompt_template = (PROMPTS_DIR / "spec_generator.md").read_text()
+    base_prompt = prompt_template.replace("{skill_content}", skill_content)
+
+    last_error: Exception | None = None
+
+    for attempt in range(max_retries + 1):
+        prompt = base_prompt
+        if attempt > 0 and last_error is not None:
+            prompt += (
+                f"\n\nPREVIOUS ATTEMPT FAILED with YAML parse error:\n"
+                f"{last_error}\n\n"
+                f"Please fix the YAML. Remember to quote all string values "
+                f"that contain colons, e.g.: description: \"Use type: description format\""
+            )
+
+        result = subprocess.run(
+            ["claude", "-p", prompt, "--model", model, "--output-format", "text"],
+            capture_output=True,
+            text=True,
+            timeout=120,
+        )
+
+        if result.returncode != 0:
+            raise RuntimeError(f"claude -p failed: {result.stderr}")
+
+        raw_yaml = extract_yaml(result.stdout)
+
+        tmp_path = None
+        with tempfile.NamedTemporaryFile(
+            mode="w", suffix=".yaml", delete=False,
+        ) as f:
+            f.write(raw_yaml)
+            tmp_path = Path(f.name)
+
+        try:
+            return parse_spec(tmp_path)
+        except (yaml.YAMLError, KeyError, TypeError) as e:
+            last_error = e
+            if attempt == max_retries:
+                raise
+        finally:
+            if tmp_path is not None:
+                tmp_path.unlink(missing_ok=True)
+
+    raise RuntimeError("unreachable")