@rubix0270/arboris 1.0.2 → 1.0.4

package/prisma/skills/skill-comply/tests/test_grader.py

@@ -1,197 +0,0 @@
-"""Tests for grader module — compliance scoring with LLM classification."""
-
-from pathlib import Path
-from unittest.mock import patch
-
-import pytest
-
-from scripts.grader import ComplianceResult, StepResult, grade
-from scripts.parser import ComplianceSpec, Detector, ObservationEvent, Step, parse_spec, parse_trace
-
-FIXTURES = Path(__file__).parent.parent / "fixtures"
-
-
-@pytest.fixture
-def tdd_spec():
-    return parse_spec(FIXTURES / "tdd_spec.yaml")
-
-
-@pytest.fixture
-def compliant_trace():
-    return parse_trace(FIXTURES / "compliant_trace.jsonl")
-
-
-@pytest.fixture
-def noncompliant_trace():
-    return parse_trace(FIXTURES / "noncompliant_trace.jsonl")
-
-
-def _mock_compliant_classification(spec, trace, model="haiku"):  # noqa: ARG001
-    """Simulate LLM correctly classifying a compliant trace."""
-    return {
-        "write_test": [0],
-        "run_test_red": [1],
-        "write_impl": [2],
-        "run_test_green": [3],
-        "refactor": [4],
-    }
-
-
-def _mock_noncompliant_classification(spec, trace, model="haiku"):
-    """Simulate LLM classifying a noncompliant trace (impl before test)."""
-    return {
-        "write_impl": [0],    # src/fib.py written first
-        "write_test": [1],    # test written second
-        "run_test_green": [2],  # only a passing test run
-    }
-
-
-def _mock_empty_classification(spec, trace, model="haiku"):
-    return {}
-
-
-class TestGradeCompliant:
-    @patch("scripts.grader.classify_events", side_effect=_mock_compliant_classification)
-    def test_returns_compliance_result(self, mock_cls, tdd_spec, compliant_trace) -> None:
-        result = grade(tdd_spec, compliant_trace)
-        assert isinstance(result, ComplianceResult)
-
-    @patch("scripts.grader.classify_events", side_effect=_mock_compliant_classification)
-    def test_full_compliance(self, mock_cls, tdd_spec, compliant_trace) -> None:
-        result = grade(tdd_spec, compliant_trace)
-        assert result.compliance_rate == 1.0
-
-    @patch("scripts.grader.classify_events", side_effect=_mock_compliant_classification)
-    def test_all_required_steps_detected(self, mock_cls, tdd_spec, compliant_trace) -> None:
-        result = grade(tdd_spec, compliant_trace)
-        required_results = [s for s in result.steps if s.step_id in
-                           ("write_test", "run_test_red", "write_impl", "run_test_green")]
-        assert all(s.detected for s in required_results)
-
-    @patch("scripts.grader.classify_events", side_effect=_mock_compliant_classification)
-    def test_optional_step_detected(self, mock_cls, tdd_spec, compliant_trace) -> None:
-        result = grade(tdd_spec, compliant_trace)
-        refactor = next(s for s in result.steps if s.step_id == "refactor")
-        assert refactor.detected is True
-
-    @patch("scripts.grader.classify_events", side_effect=_mock_compliant_classification)
-    def test_no_hook_promotion_recommended(self, mock_cls, tdd_spec, compliant_trace) -> None:
-        result = grade(tdd_spec, compliant_trace)
-        assert result.recommend_hook_promotion is False
-
-    @patch("scripts.grader.classify_events", side_effect=_mock_compliant_classification)
-    def test_step_evidence_not_empty(self, mock_cls, tdd_spec, compliant_trace) -> None:
-        result = grade(tdd_spec, compliant_trace)
-        for step in result.steps:
-            if step.detected:
-                assert len(step.evidence) > 0
-
-
-class TestGradeNoncompliant:
-    @patch("scripts.grader.classify_events", side_effect=_mock_noncompliant_classification)
-    def test_low_compliance(self, mock_cls, tdd_spec, noncompliant_trace) -> None:
-        result = grade(tdd_spec, noncompliant_trace)
-        assert result.compliance_rate < 1.0
-
-    @patch("scripts.grader.classify_events", side_effect=_mock_noncompliant_classification)
-    def test_write_test_fails_ordering(self, mock_cls, tdd_spec, noncompliant_trace) -> None:
-        """write_test has before_step=write_impl, but test is written AFTER impl."""
-        result = grade(tdd_spec, noncompliant_trace)
-        write_test = next(s for s in result.steps if s.step_id == "write_test")
-        assert write_test.detected is False
-
-    @patch("scripts.grader.classify_events", side_effect=_mock_noncompliant_classification)
-    def test_run_test_red_not_detected(self, mock_cls, tdd_spec, noncompliant_trace) -> None:
-        result = grade(tdd_spec, noncompliant_trace)
-        run_red = next(s for s in result.steps if s.step_id == "run_test_red")
-        assert run_red.detected is False
-
-    @patch("scripts.grader.classify_events", side_effect=_mock_noncompliant_classification)
-    def test_hook_promotion_recommended(self, mock_cls, tdd_spec, noncompliant_trace) -> None:
-        result = grade(tdd_spec, noncompliant_trace)
-        assert result.recommend_hook_promotion is True
-
-    @patch("scripts.grader.classify_events", side_effect=_mock_noncompliant_classification)
-    def test_failure_reasons_present(self, mock_cls, tdd_spec, noncompliant_trace) -> None:
-        result = grade(tdd_spec, noncompliant_trace)
-        failed_steps = [s for s in result.steps if not s.detected and s.step_id != "refactor"]
-        for step in failed_steps:
-            assert step.failure_reason is not None
-
-
-class TestGradeEdgeCases:
-    @patch("scripts.grader.classify_events", side_effect=_mock_empty_classification)
-    def test_empty_trace(self, mock_cls, tdd_spec) -> None:
-        result = grade(tdd_spec, [])
-        assert result.compliance_rate == 0.0
-        assert result.recommend_hook_promotion is True
-
-    @patch("scripts.grader.classify_events", side_effect=_mock_compliant_classification)
-    def test_compliance_rate_is_ratio_of_required_only(self, mock_cls, tdd_spec, compliant_trace) -> None:
-        result = grade(tdd_spec, compliant_trace)
-        assert result.compliance_rate == 1.0
-
-    @patch("scripts.grader.classify_events", side_effect=_mock_compliant_classification)
-    def test_spec_id_in_result(self, mock_cls, tdd_spec, compliant_trace) -> None:
-        result = grade(tdd_spec, compliant_trace)
-        assert result.spec_id == "tdd-workflow"
-
-    @patch("scripts.grader.classify_events")
-    def test_after_step_can_reference_later_declared_spec_step(self, mock_cls) -> None:
-        spec = ComplianceSpec(
-            id="out-of-order-after-step",
-            name="Out of order after_step",
-            source_rule="rules/common/testing.md",
-            version="1.0",
-            steps=(
-                Step(
-                    id="step_a",
-                    description="Occurs after step_b even though it is declared first",
-                    required=True,
-                    detector=Detector(
-                        description="Event A",
-                        after_step="step_b",
-                    ),
-                ),
-                Step(
-                    id="step_b",
-                    description="Reference step declared later",
-                    required=True,
-                    detector=Detector(
-                        description="Event B",
-                    ),
-                ),
-            ),
-            threshold_promote_to_hook=0.5,
-        )
-        trace = [
-            ObservationEvent(
-                timestamp="2026-03-20T10:00:01Z",
-                event="tool_complete",
-                tool="Write",
-                session="sess-order",
-                input='{"file_path":"src/b.py"}',
-                output="step b",
-            ),
-            ObservationEvent(
-                timestamp="2026-03-20T10:00:02Z",
-                event="tool_complete",
-                tool="Write",
-                session="sess-order",
-                input='{"file_path":"src/a.py"}',
-                output="step a",
-            ),
-        ]
-        mock_cls.return_value = {
-            "step_a": [1],
-            "step_b": [0],
-        }
-
-        result = grade(spec, trace)
-
-        step_a = next(step for step in result.steps if step.step_id == "step_a")
-        step_b = next(step for step in result.steps if step.step_id == "step_b")
-        assert step_a.detected is True
-        assert step_a.failure_reason is None
-        assert step_b.detected is True
-        assert result.compliance_rate == 1.0

package/prisma/skills/skill-comply/tests/test_parser.py

@@ -1,90 +0,0 @@
-"""Tests for parser module — JSONL trace and YAML spec parsing."""
-
-from pathlib import Path
-
-import pytest
-
-from scripts.parser import (
-    ComplianceSpec,
-    Detector,
-    ObservationEvent,
-    Step,
-    parse_spec,
-    parse_trace,
-)
-
-FIXTURES = Path(__file__).parent.parent / "fixtures"
-
-
-class TestParseTrace:
-    def test_parses_compliant_trace(self) -> None:
-        events = parse_trace(FIXTURES / "compliant_trace.jsonl")
-        assert len(events) == 5
-        assert all(isinstance(e, ObservationEvent) for e in events)
-
-    def test_events_sorted_by_timestamp(self) -> None:
-        events = parse_trace(FIXTURES / "compliant_trace.jsonl")
-        timestamps = [e.timestamp for e in events]
-        assert timestamps == sorted(timestamps)
-
-    def test_event_fields(self) -> None:
-        events = parse_trace(FIXTURES / "compliant_trace.jsonl")
-        first = events[0]
-        assert first.tool == "Write"
-        assert first.session == "sess-001"
-        assert "test_fib.py" in first.input
-        assert first.output == "File created"
-
-    def test_parses_noncompliant_trace(self) -> None:
-        events = parse_trace(FIXTURES / "noncompliant_trace.jsonl")
-        assert len(events) == 3
-        assert "src/fib.py" in events[0].input
-
-    def test_empty_file_returns_empty_list(self, tmp_path: Path) -> None:
-        empty = tmp_path / "empty.jsonl"
-        empty.write_text("")
-        events = parse_trace(empty)
-        assert events == []
-
-    def test_nonexistent_file_raises(self) -> None:
-        with pytest.raises(FileNotFoundError):
-            parse_trace(Path("/nonexistent/trace.jsonl"))
-
-
-class TestParseSpec:
-    def test_parses_tdd_spec(self) -> None:
-        spec = parse_spec(FIXTURES / "tdd_spec.yaml")
-        assert isinstance(spec, ComplianceSpec)
-        assert spec.id == "tdd-workflow"
-        assert len(spec.steps) == 5
-
-    def test_step_fields(self) -> None:
-        spec = parse_spec(FIXTURES / "tdd_spec.yaml")
-        first = spec.steps[0]
-        assert isinstance(first, Step)
-        assert first.id == "write_test"
-        assert first.required is True
-        assert isinstance(first.detector, Detector)
-        assert "test file" in first.detector.description
-        assert first.detector.before_step == "write_impl"
-
-    def test_optional_detector_fields(self) -> None:
-        spec = parse_spec(FIXTURES / "tdd_spec.yaml")
-        write_test = spec.steps[0]
-        assert write_test.detector.after_step is None
-
-        run_test_red = spec.steps[1]
-        assert run_test_red.detector.after_step == "write_test"
-        assert run_test_red.detector.before_step == "write_impl"
-
-    def test_scoring_threshold(self) -> None:
-        spec = parse_spec(FIXTURES / "tdd_spec.yaml")
-        assert spec.threshold_promote_to_hook == 0.6
-
-    def test_required_vs_optional_steps(self) -> None:
-        spec = parse_spec(FIXTURES / "tdd_spec.yaml")
-        required = [s for s in spec.steps if s.required]
-        optional = [s for s in spec.steps if not s.required]
-        assert len(required) == 4
-        assert len(optional) == 1
-        assert optional[0].id == "refactor"

package/prisma/skills/skill-comply/tests/test_runner.py

@@ -1,172 +0,0 @@
-"""Tests for runner module — scenario execution + subprocess error handling."""
-
-from __future__ import annotations
-
-import subprocess
-from dataclasses import dataclass
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-from scripts.runner import _setup_sandbox, run_scenario
-
-
-@dataclass(frozen=True)
-class _FakeScenario:
-    """Minimal Scenario-like object for runner tests (avoids generator deps)."""
-
-    id: str
-    prompt: str = "do nothing"
-    setup_commands: tuple[str, ...] = ()
-
-
-class TestSetupSandboxSkipsShellBuiltins:
-    """Setup commands containing shell builtins (cd/pushd/popd) must be skipped.
-
-    Regression: subprocess.run(["cd", ...]) raises FileNotFoundError because
-    cd is a shell builtin, not an external binary. Real-world scenarios often
-    include "cd subdir" in setup_commands assuming shell semantics, so the
-    runner must tolerate this rather than crashing the whole scenario.
-    """
-
-    def test_skips_cd(self, tmp_path):
-        scenario = _FakeScenario(
-            id="t1",
-            setup_commands=("cd subdir",),
-        )
-        called_args: list[list[str]] = []
-
-        def fake_run(args, **kwargs):
-            called_args.append(args)
-            return subprocess.CompletedProcess(args=args, returncode=0)
-
-        with patch("scripts.runner.subprocess.run", side_effect=fake_run):
-            _setup_sandbox(tmp_path, scenario)
-
-        # git init runs once; "cd subdir" must NOT be passed to subprocess
-        assert ["git", "init"] in called_args
-        assert ["cd", "subdir"] not in called_args
-
-    def test_skips_pushd_popd(self, tmp_path):
-        scenario = _FakeScenario(
-            id="t2",
-            setup_commands=("pushd dir", "popd"),
-        )
-        called_args: list[list[str]] = []
-
-        def fake_run(args, **kwargs):
-            called_args.append(args)
-            return subprocess.CompletedProcess(args=args, returncode=0)
-
-        with patch("scripts.runner.subprocess.run", side_effect=fake_run):
-            _setup_sandbox(tmp_path, scenario)
-
-        assert ["pushd", "dir"] not in called_args
-        assert ["popd"] not in called_args
-
-    def test_tolerates_missing_executable(self, tmp_path):
-        """A scenario referencing an unavailable tool must not crash setup."""
-        scenario = _FakeScenario(
-            id="t3",
-            setup_commands=("nonexistent-tool-xyz arg",),
-        )
-
-        def fake_run(args, **kwargs):
-            if args[0] == "nonexistent-tool-xyz":
-                raise FileNotFoundError(2, "No such file or directory")
-            return subprocess.CompletedProcess(args=args, returncode=0)
-
-        with patch("scripts.runner.subprocess.run", side_effect=fake_run):
-            # Must NOT raise — missing tools are skipped, not fatal
-            _setup_sandbox(tmp_path, scenario)
-
-    def test_real_commands_still_run(self, tmp_path):
-        """Skip logic must not break legitimate setup commands."""
-        scenario = _FakeScenario(
-            id="t4",
-            setup_commands=("touch file.txt", "cd ignored", "echo hi"),
-        )
-        called_args: list[list[str]] = []
-
-        def fake_run(args, **kwargs):
-            called_args.append(args)
-            return subprocess.CompletedProcess(args=args, returncode=0)
-
-        with patch("scripts.runner.subprocess.run", side_effect=fake_run):
-            _setup_sandbox(tmp_path, scenario)
-
-        # Real commands present, cd absent
-        assert ["touch", "file.txt"] in called_args
-        assert ["echo", "hi"] in called_args
-        assert ["cd", "ignored"] not in called_args
-
-
-class TestRunScenarioMaxTurnsTermination:
-    """rc=1 with terminal_reason=max_turns is graceful termination, not failure.
-
-    claude -p returns rc=1 when --max-turns is reached, but the stream-json
-    output is still valid. Treating this as RuntimeError aborts scenarios
-    that would have produced useful observations. Detect the marker in stdout
-    and downgrade rc=1 + max_turns to non-fatal.
-    """
-
-    def test_rc1_with_max_turns_marker_returns_normally(self, tmp_path, monkeypatch):
-        scenario = _FakeScenario(id="mt1", prompt="long task", setup_commands=())
-
-        # Skip sandbox setup side effects
-        monkeypatch.setattr("scripts.runner._setup_sandbox", lambda *a, **kw: None)
-
-        max_turns_stdout = (
-            '{"type":"system","subtype":"init","session_id":"s1"}\n'
-            '{"type":"result","terminal_reason":"max_turns"}\n'
-        )
-
-        fake_result = subprocess.CompletedProcess(
-            args=["claude"], returncode=1, stdout=max_turns_stdout, stderr=""
-        )
-
-        with patch("scripts.runner.subprocess.run", return_value=fake_result):
-            # Must NOT raise — max_turns is graceful termination
-            run_scenario(scenario, model="haiku")
-
-    def test_rc1_without_max_turns_marker_still_raises(self, tmp_path, monkeypatch):
-        """Real failures (rc≠0 with no max_turns marker) must still raise."""
-        scenario = _FakeScenario(id="mt2", prompt="oops", setup_commands=())
-        monkeypatch.setattr("scripts.runner._setup_sandbox", lambda *a, **kw: None)
-
-        fake_result = subprocess.CompletedProcess(
-            args=["claude"], returncode=1, stdout="", stderr="auth error"
-        )
-
-        with patch("scripts.runner.subprocess.run", return_value=fake_result):
-            with pytest.raises(RuntimeError, match="claude -p failed"):
-                run_scenario(scenario, model="haiku")
-
-
-class TestRunScenarioErrorIncludesStdoutTail:
-    """Error messages must include stdout tail, not only stderr.
-
-    When claude -p fails inside an LLM call, useful diagnostic context often
-    appears in stdout (partial stream-json events, model error JSON), not
-    stderr. Including stdout tail in the RuntimeError message dramatically
-    improves debug-ability without adding any new dependency.
-    """
-
-    def test_error_message_contains_stdout_tail(self, tmp_path, monkeypatch):
-        scenario = _FakeScenario(id="e1", prompt="x", setup_commands=())
-        monkeypatch.setattr("scripts.runner._setup_sandbox", lambda *a, **kw: None)
-
-        diagnostic_marker = "DIAG_STDOUT_MARKER_xyz123"
-        fake_result = subprocess.CompletedProcess(
-            args=["claude"],
-            returncode=2,
-            stdout=f"some context {diagnostic_marker} more text",
-            stderr="generic error",
-        )
-
-        with patch("scripts.runner.subprocess.run", return_value=fake_result):
-            with pytest.raises(RuntimeError) as excinfo:
-                run_scenario(scenario, model="haiku")
-
-        # Stdout marker MUST appear in the error message
-        assert diagnostic_marker in str(excinfo.value)

package/prisma/skills/skill-scout/SKILL.md

@@ -1,141 +0,0 @@
----
-name: skill-scout
-description: Search existing local, marketplace, GitHub, and web skill sources before creating a new skill. Use when the user wants to create, build, fork, or find a skill for a workflow.
-metadata:
-  origin: community
----
-
-# Skill Scout
-
-Use this skill before creating a new skill. The goal is to avoid duplicating
-existing community or marketplace work, while still vetting anything external
-before adoption.
-
-Source: salvaged from stale community PR #1232 by `redminwang`.
-
-## When to Use
-
-- The user says "create a skill", "build a skill", "make a skill", or "new
-  skill".
-- The user asks "is there a skill for X?" or "does a skill exist that does Y?"
-- The user describes a workflow and you are about to suggest creating a new
-  skill.
-- The user wants to fork or extend an existing skill.
-
-If the user explicitly says to skip search or create from scratch, acknowledge
-that and proceed with the requested creation workflow.
-
-## How It Works
-
-### Step 1 - Capture Intent
-
-Extract:
-
-- The task the skill should perform.
-- The trigger conditions for using it.
-- The domain, tools, frameworks, or data sources involved.
-- Three to five search keywords plus useful synonyms.
-
-### Step 2 - Search Local Sources
-
-Search installed and marketplace skill names first. Local sources are preferred
-because they are already part of the user's environment.
-
-```bash
-find ~/.claude/skills -maxdepth 2 -name SKILL.md 2>/dev/null | grep -iE "keyword|synonym"
-find ~/.claude/plugins/marketplaces -path '*/skills/*/SKILL.md' 2>/dev/null | grep -iE "keyword|synonym"
-```
-
-Then search frontmatter descriptions:
-
-```bash
-grep -RilE "keyword|synonym" ~/.claude/skills ~/.claude/plugins/marketplaces 2>/dev/null
-```
-
-### Step 3 - Search Remote Sources
-
-Use available GitHub and web search tools. Prefer concise queries:
-
-```bash
-gh search repos "claude code skill keyword" --limit 10 --sort stars
-gh search code "name: keyword" --filename SKILL.md --limit 10
-```
-
-For web search, use at most three targeted queries such as:
-
-```text
-"claude code skill" keyword
-"SKILL.md" keyword
-"everything-claude-code" keyword
-```
-
-### Step 4 - Vet External Matches
-
-Before recommending any external skill for adoption or forking:
-
-- Read the `SKILL.md` frontmatter and instructions.
-- Look for unexpected shell commands, file writes, network calls, credential
-  handling, or package installs.
-- Check whether the repository appears maintained.
-- Prefer copying into a fresh local branch and reviewing the diff over editing
-  marketplace originals.
-
-### Step 5 - Rank Results
-
-Rank candidates by:
-
-1. Exact keyword match in the skill name.
-2. Keyword or synonym match in description.
-3. Local installed or marketplace source.
-4. Maintained GitHub source with recent activity.
-5. Web-only mention.
-
-Cap the final list at 10 results.
-
-### Step 6 - Present Decision Options
-
-Give the user a short table:
-
-| Option | Meaning |
-| --- | --- |
-| Use existing | Invoke or install a matching skill as-is. |
-| Fork or extend | Copy the closest skill and modify it. |
-| Create fresh | Build a new skill after confirming no close match exists. |
-
-Only create a new skill after the user chooses that path or after the search
-finds no close match.
-
-## Examples
-
-### Result Table
-
-```markdown
-| # | Skill | Source | Why it matches | Gap |
-| --- | --- | --- | --- | --- |
-| 1 | article-writing | Local ECC | Drafts articles and guides | Not focused on release notes |
-| 2 | content-engine | Local ECC | Multi-format content workflow | Heavier than needed |
-| 3 | blog-writer | GitHub | Blog writing skill with recent commits | Needs security review |
-```
-
-### User-Facing Summary
-
-```markdown
-I found two close local matches and one external candidate. The closest fit is
-`article-writing`; it covers drafting and revision, but it does not include the
-release-note checklist you asked for. I can either use it as-is, fork it into a
-release-note variant, or create a fresh skill.
-```
-
-## Anti-Patterns
-
-- Do not jump directly to new skill creation when a search is reasonable.
-- Do not install external skills without reading them first.
-- Do not present a long unranked list of weak matches.
-- Do not treat web-only mentions as trusted sources.
-- Do not edit installed marketplace originals in place.
-
-## Related
-
-- `search-first` - General search-before-building workflow.
-- `skill-stocktake` - Audit installed skills for health, duplicates, and gaps.
-- `agent-sort` - Categorize and organize existing agents and skills.