agentic-sigma-reveal 0.2.0__tar.gz

agentic_sigma_reveal-0.2.0/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: agentic-sigma-reveal
+Version: 0.2.0
+Summary: Task-conditioned, budgeted initial workspace observation for CLI agent harnesses
+Project-URL: Repository, https://github.com/Hoyant-Su/Agentic-Sigma-Reveal
+Project-URL: Paper, https://arxiv.org/abs/2605.08013
+Keywords: agent-harness,context-selection,cli-agent,sigma-reveal
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Provides-Extra: mcp
+Requires-Dist: mcp<3,>=2.2; extra == "mcp"
+Provides-Extra: deepagents
+Requires-Dist: deepagents<0.8,>=0.7.13; extra == "deepagents"
+
+# Agentic Sigma-Reveal
+
+Task-conditioned initial workspace observations for agent harnesses, with ancestor-closed tree selection under a character budget.
+
+```bash
+pip install git+https://github.com/Hoyant-Su/Agentic-Sigma-Reveal.git
+sigma-reveal ./workspace --task "Analyze sales.csv with Python" --budget-chars 2400
+```
+
+```python
+from sigma_reveal import reveal
+from sigma_reveal_reference import METHOD
+
+context = reveal("./workspace", "Analyze sales.csv with Python", budget_chars=2400)
+method_reference = METHOD
+```
+
+The selector preserves the released method's scoring and tree optimization. Line costs are rounded up to 16-character buckets. The default budget is 2400 characters. Only the initial observation is generated; the receiving harness supplies subsequent observations.
+
+## Local MCP
+
+```bash
+pip install 'agentic-sigma-reveal[mcp] @ git+https://github.com/Hoyant-Su/Agentic-Sigma-Reveal.git'
+sigma-reveal-mcp --workspace ./workspace
+```
+
+The stdio server exposes `select_workspace_context(task, budget_chars)` and `describe_method()`. Selection returns the workspace view and original method reference, including BibTeX. The `sigma-reveal://reference` resource returns the BibTeX alone. Client configuration after installation:
+
+```json
+{
+  "mcpServers": {
+    "sigma-reveal": {
+      "command": "sigma-reveal-mcp",
+      "args": ["--workspace", "/path/to/task-workspace"]
+    }
+  }
+}
+```
+
+The server binds to the workspace supplied at startup. Use a prepared workspace whose files may be read by the model. The MCP interface rejects symbolic links and special files in the inspected tree. Direct Python and CLI selection retain the original traversal behavior, including following symlinks. Keep the workspace unchanged during selection. File previews are untrusted task data.
+
+The selector inspects up to four levels and reads up to 160 bytes per file for an 80-character first-line preview. The view budget constrains rendered output; it does not bound the number of directory entries inspected. Dynamic programming scales with tree size and the square of the budget in buckets.
+
+## Harness integration
+
+`examples/deepagents_initial_context.py` supplies a static selected view to Deep Agents before its first action. See `examples/deepagents.md` for invocation and scope.
+
+## Method reference
+
+The reference identifies the original observation method (section 3.2). The paper formulates a token-budget objective; its released implementation uses character buckets, as exposed by this package.
+
+```bibtex
+@article{su2026structuredactioncredit,
+  title = {Learning CLI Agents with Structured Action Credit under Selective Observation},
+  author = {Su, Haoyang and Wen, Ying},
+  year = {2026},
+  journal = {arXiv preprint arXiv:2605.08013},
+  doi = {10.48550/arXiv.2605.08013},
+  url = {https://arxiv.org/abs/2605.08013}
+}
+```

agentic_sigma_reveal-0.2.0/USAGE.md

@@ -0,0 +1,61 @@
+# Agentic Sigma-Reveal
+
+Task-conditioned initial workspace observations for agent harnesses, with ancestor-closed tree selection under a character budget.
+
+```bash
+pip install git+https://github.com/Hoyant-Su/Agentic-Sigma-Reveal.git
+sigma-reveal ./workspace --task "Analyze sales.csv with Python" --budget-chars 2400
+```
+
+```python
+from sigma_reveal import reveal
+from sigma_reveal_reference import METHOD
+
+context = reveal("./workspace", "Analyze sales.csv with Python", budget_chars=2400)
+method_reference = METHOD
+```
+
+The selector preserves the released method's scoring and tree optimization. Line costs are rounded up to 16-character buckets. The default budget is 2400 characters. Only the initial observation is generated; the receiving harness supplies subsequent observations.
+
+## Local MCP
+
+```bash
+pip install 'agentic-sigma-reveal[mcp] @ git+https://github.com/Hoyant-Su/Agentic-Sigma-Reveal.git'
+sigma-reveal-mcp --workspace ./workspace
+```
+
+The stdio server exposes `select_workspace_context(task, budget_chars)` and `describe_method()`. Selection returns the workspace view and original method reference, including BibTeX. The `sigma-reveal://reference` resource returns the BibTeX alone. Client configuration after installation:
+
+```json
+{
+  "mcpServers": {
+    "sigma-reveal": {
+      "command": "sigma-reveal-mcp",
+      "args": ["--workspace", "/path/to/task-workspace"]
+    }
+  }
+}
+```
+
+The server binds to the workspace supplied at startup. Use a prepared workspace whose files may be read by the model. The MCP interface rejects symbolic links and special files in the inspected tree. Direct Python and CLI selection retain the original traversal behavior, including following symlinks. Keep the workspace unchanged during selection. File previews are untrusted task data.
+
+The selector inspects up to four levels and reads up to 160 bytes per file for an 80-character first-line preview. The view budget constrains rendered output; it does not bound the number of directory entries inspected. Dynamic programming scales with tree size and the square of the budget in buckets.
+
+## Harness integration
+
+`examples/deepagents_initial_context.py` supplies a static selected view to Deep Agents before its first action. See `examples/deepagents.md` for invocation and scope.
+
+## Method reference
+
+The reference identifies the original observation method (section 3.2). The paper formulates a token-budget objective; its released implementation uses character buckets, as exposed by this package.
+
+```bibtex
+@article{su2026structuredactioncredit,
+  title = {Learning CLI Agents with Structured Action Credit under Selective Observation},
+  author = {Su, Haoyang and Wen, Ying},
+  year = {2026},
+  journal = {arXiv preprint arXiv:2605.08013},
+  doi = {10.48550/arXiv.2605.08013},
+  url = {https://arxiv.org/abs/2605.08013}
+}
+```

agentic_sigma_reveal-0.2.0/agentic_sigma_reveal.egg-info/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: agentic-sigma-reveal
+Version: 0.2.0
+Summary: Task-conditioned, budgeted initial workspace observation for CLI agent harnesses
+Project-URL: Repository, https://github.com/Hoyant-Su/Agentic-Sigma-Reveal
+Project-URL: Paper, https://arxiv.org/abs/2605.08013
+Keywords: agent-harness,context-selection,cli-agent,sigma-reveal
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Provides-Extra: mcp
+Requires-Dist: mcp<3,>=2.2; extra == "mcp"
+Provides-Extra: deepagents
+Requires-Dist: deepagents<0.8,>=0.7.13; extra == "deepagents"
+
+# Agentic Sigma-Reveal
+
+Task-conditioned initial workspace observations for agent harnesses, with ancestor-closed tree selection under a character budget.
+
+```bash
+pip install git+https://github.com/Hoyant-Su/Agentic-Sigma-Reveal.git
+sigma-reveal ./workspace --task "Analyze sales.csv with Python" --budget-chars 2400
+```
+
+```python
+from sigma_reveal import reveal
+from sigma_reveal_reference import METHOD
+
+context = reveal("./workspace", "Analyze sales.csv with Python", budget_chars=2400)
+method_reference = METHOD
+```
+
+The selector preserves the released method's scoring and tree optimization. Line costs are rounded up to 16-character buckets. The default budget is 2400 characters. Only the initial observation is generated; the receiving harness supplies subsequent observations.
+
+## Local MCP
+
+```bash
+pip install 'agentic-sigma-reveal[mcp] @ git+https://github.com/Hoyant-Su/Agentic-Sigma-Reveal.git'
+sigma-reveal-mcp --workspace ./workspace
+```
+
+The stdio server exposes `select_workspace_context(task, budget_chars)` and `describe_method()`. Selection returns the workspace view and original method reference, including BibTeX. The `sigma-reveal://reference` resource returns the BibTeX alone. Client configuration after installation:
+
+```json
+{
+  "mcpServers": {
+    "sigma-reveal": {
+      "command": "sigma-reveal-mcp",
+      "args": ["--workspace", "/path/to/task-workspace"]
+    }
+  }
+}
+```
+
+The server binds to the workspace supplied at startup. Use a prepared workspace whose files may be read by the model. The MCP interface rejects symbolic links and special files in the inspected tree. Direct Python and CLI selection retain the original traversal behavior, including following symlinks. Keep the workspace unchanged during selection. File previews are untrusted task data.
+
+The selector inspects up to four levels and reads up to 160 bytes per file for an 80-character first-line preview. The view budget constrains rendered output; it does not bound the number of directory entries inspected. Dynamic programming scales with tree size and the square of the budget in buckets.
+
+## Harness integration
+
+`examples/deepagents_initial_context.py` supplies a static selected view to Deep Agents before its first action. See `examples/deepagents.md` for invocation and scope.
+
+## Method reference
+
+The reference identifies the original observation method (section 3.2). The paper formulates a token-budget objective; its released implementation uses character buckets, as exposed by this package.
+
+```bibtex
+@article{su2026structuredactioncredit,
+  title = {Learning CLI Agents with Structured Action Credit under Selective Observation},
+  author = {Su, Haoyang and Wen, Ying},
+  year = {2026},
+  journal = {arXiv preprint arXiv:2605.08013},
+  doi = {10.48550/arXiv.2605.08013},
+  url = {https://arxiv.org/abs/2605.08013}
+}
+```

agentic_sigma_reveal-0.2.0/agentic_sigma_reveal.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+USAGE.md
+pyproject.toml
+sigma_reveal.py
+sigma_reveal_mcp.py
+sigma_reveal_reference.py
+agentic_sigma_reveal.egg-info/PKG-INFO
+agentic_sigma_reveal.egg-info/SOURCES.txt
+agentic_sigma_reveal.egg-info/dependency_links.txt
+agentic_sigma_reveal.egg-info/entry_points.txt
+agentic_sigma_reveal.egg-info/requires.txt
+agentic_sigma_reveal.egg-info/top_level.txt
+tests/test_mcp.py
+tests/test_selection.py

agentic_sigma_reveal-0.2.0/agentic_sigma_reveal.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

agentic_sigma_reveal-0.2.0/agentic_sigma_reveal.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+sigma-reveal = sigma_reveal:main
+sigma-reveal-mcp = sigma_reveal_mcp:main

agentic_sigma_reveal-0.2.0/agentic_sigma_reveal.egg-info/requires.txt

@@ -0,0 +1,6 @@
+
+[deepagents]
+deepagents<0.8,>=0.7.13
+
+[mcp]
+mcp<3,>=2.2

agentic_sigma_reveal-0.2.0/agentic_sigma_reveal.egg-info/top_level.txt

@@ -0,0 +1,3 @@
+sigma_reveal
+sigma_reveal_mcp
+sigma_reveal_reference

agentic_sigma_reveal-0.2.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "agentic-sigma-reveal"
+version = "0.2.0"
+description = "Task-conditioned, budgeted initial workspace observation for CLI agent harnesses"
+requires-python = ">=3.10"
+readme = "USAGE.md"
+keywords = ["agent-harness", "context-selection", "cli-agent", "sigma-reveal"]
+
+[project.optional-dependencies]
+mcp = ["mcp>=2.2,<3"]
+deepagents = ["deepagents>=0.7.13,<0.8"]
+
+[project.scripts]
+sigma-reveal = "sigma_reveal:main"
+sigma-reveal-mcp = "sigma_reveal_mcp:main"
+
+[project.urls]
+Repository = "https://github.com/Hoyant-Su/Agentic-Sigma-Reveal"
+Paper = "https://arxiv.org/abs/2605.08013"
+
+[tool.setuptools]
+py-modules = ["sigma_reveal", "sigma_reveal_reference", "sigma_reveal_mcp"]

agentic_sigma_reveal-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

agentic_sigma_reveal-0.2.0/sigma_reveal.py

@@ -0,0 +1,248 @@
+from __future__ import annotations
+import argparse
+import os
+import re
+
+_BUDGET_CHARS = 2400
+_BUCKET_CHARS = 16
+_MAX_DEPTH = 4
+_MAX_HEAD_BYTES = 160
+_LAMBDA_CITE = 4.0
+_LAMBDA_DEPTH = 1.0
+_LAMBDA_EXT = 0.8
+_ALPHA_DEPTH = 0.7
+_DIR_EXT_BASE = 0.3
+_DATA_EXTS = {".csv", ".tsv", ".json", ".jsonl", ".txt", ".yaml", ".yml", ".log"}
+_CODE_EXTS = {
+    ".py",
+    ".c",
+    ".cpp",
+    ".h",
+    ".hpp",
+    ".sh",
+    ".js",
+    ".ts",
+    ".go",
+    ".rs",
+    ".rb",
+}
+_DATA_CUES = ("csv", "tsv", "json", "yaml", "dataset", "data", "table", "row", "column")
+_CODE_CUES = (
+    "script",
+    "function",
+    "class",
+    "module",
+    "python",
+    ".py",
+    "compile",
+    "run",
+)
+_TOKEN_RE = re.compile(r"[A-Za-z0-9_./-]+")
+
+def _is_probably_text(data: bytes) -> bool:
+    if b"\x00" in data:
+        return False
+    printable = sum(1 for b in data if 9 <= b <= 13 or 32 <= b <= 126)
+    return printable / max(len(data), 1) >= 0.85
+
+def _o0_token_set(text: str) -> set[str]:
+    out: set[str] = set()
+    for tok in _TOKEN_RE.findall(text):
+        t = tok.strip(".")
+        if not t:
+            continue
+        out.add(t)
+        out.add(t.lower())
+        stem = os.path.splitext(t)[0]
+        if stem and stem != t:
+            out.add(stem)
+            out.add(stem.lower())
+    return out
+
+def _task_type_weights(text: str) -> tuple[float, float]:
+    low = text.lower()
+    data_hits = sum(1 for c in _DATA_CUES if c in low)
+    code_hits = sum(1 for c in _CODE_CUES if c in low)
+    total = data_hits + code_hits
+    if total == 0:
+        return 0.5, 0.5
+    return data_hits / total, code_hits / total
+
+def _render_file_line(
+    name: str, size: int, is_text: bool, head: bytes, indent: str
+) -> str:
+    if not is_text:
+        return f"{indent}{name} ({size} B, binary)"
+    first_line = head.split(b"\n", 1)[0].decode("utf-8", "replace").strip()
+    if not first_line:
+        return f"{indent}{name} ({size} B, empty)"
+    if len(first_line) > 80:
+        first_line = first_line[:77] + "..."
+    return f"{indent}{name} ({size} B) -> {first_line!r}"
+
+def _cite_score(name: str, o0_tokens: set[str]) -> float:
+    stem = os.path.splitext(name)[0]
+    if name in o0_tokens or name.lower() in o0_tokens:
+        return 1.0
+    if stem and (stem in o0_tokens or stem.lower() in o0_tokens):
+        return 1.0
+    return 0.0
+
+def _ext_score(name: str, is_dir: bool, w_data: float, w_code: float) -> float:
+    if is_dir:
+        return _DIR_EXT_BASE
+    ext = os.path.splitext(name)[1].lower()
+    if ext in _DATA_EXTS:
+        return w_data
+    if ext in _CODE_EXTS:
+        return w_code
+    return 0.0
+
+def _mu_hat(
+    name: str,
+    is_dir: bool,
+    depth: int,
+    o0_tokens: set[str],
+    w_data: float,
+    w_code: float,
+) -> float:
+    cite = _cite_score(name, o0_tokens)
+    depth_prior = _ALPHA_DEPTH**depth
+    ext = _ext_score(name, is_dir, w_data, w_code)
+    return _LAMBDA_CITE * cite + _LAMBDA_DEPTH * depth_prior + _LAMBDA_EXT * ext
+
+class _Node:
+    __slots__ = ("idx", "name", "depth", "is_dir", "line", "cost_b", "mu", "children")
+
+    def __init__(
+        self,
+        idx: int,
+        name: str,
+        depth: int,
+        is_dir: bool,
+        line: str,
+        cost_b: int,
+        mu: float,
+    ) -> None:
+        self.idx = idx
+        self.name = name
+        self.depth = depth
+        self.is_dir = is_dir
+        self.line = line
+        self.cost_b = cost_b
+        self.mu = mu
+        self.children: list[_Node] = []
+
+def _build_tree(
+    root_path: str,
+    o0_tokens: set[str],
+    w_data: float,
+    w_code: float,
+) -> _Node:
+    counter = [0]
+
+    def make_node(name: str, depth: int, is_dir: bool, line: str) -> _Node:
+        cost_b = max(1, (len(line) + 1 + _BUCKET_CHARS - 1) // _BUCKET_CHARS)
+        mu = _mu_hat(name, is_dir, depth, o0_tokens, w_data, w_code)
+        n = _Node(counter[0], name, depth, is_dir, line, cost_b, mu)
+        counter[0] += 1
+        return n
+
+    root = make_node(".", 0, True, ".")
+
+    def walk(path: str, parent: _Node, depth: int) -> None:
+        if depth > _MAX_DEPTH:
+            return
+        for child_name in sorted(os.listdir(path)):
+            child_path = os.path.join(path, child_name)
+            if os.path.isdir(child_path):
+                indent = "  " * depth
+                line = f"{indent}{child_name}/"
+                node = make_node(child_name, depth, True, line)
+                parent.children.append(node)
+                walk(child_path, node, depth + 1)
+            else:
+                size = os.path.getsize(child_path)
+                with open(child_path, "rb") as fh:
+                    head = fh.read(_MAX_HEAD_BYTES)
+                is_text = _is_probably_text(head)
+                indent = "  " * depth
+                line = _render_file_line(child_name, size, is_text, head, indent)
+                parent.children.append(make_node(child_name, depth, False, line))
+
+    walk(root_path, root, 1)
+    return root
+
+def _subtree_knapsack(root: _Node, budget_b: int) -> set[int]:
+    NEG = float("-inf")
+
+    def dfs(v: _Node) -> tuple[list[float], list[set[int]]]:
+        dp = [NEG] * (budget_b + 1)
+        pick: list[set[int]] = [set() for _ in range(budget_b + 1)]
+        if v.cost_b <= budget_b:
+            dp[v.cost_b] = v.mu
+            pick[v.cost_b] = {v.idx}
+        for child in v.children:
+            c_dp, c_pick = dfs(child)
+            new_dp = dp[:]
+            new_pick = [s.copy() for s in pick]
+            for bv in range(budget_b + 1):
+                if dp[bv] == NEG:
+                    continue
+                remain = budget_b - bv
+                for bu in range(remain + 1):
+                    if c_dp[bu] == NEG:
+                        continue
+                    val = dp[bv] + c_dp[bu]
+                    tot = bv + bu
+                    if val > new_dp[tot]:
+                        new_dp[tot] = val
+                        new_pick[tot] = pick[bv] | c_pick[bu]
+            dp = new_dp
+            pick = new_pick
+        return dp, pick
+
+    dp, pick = dfs(root)
+    best_b = 0
+    best_v = dp[0] if dp[0] != NEG else NEG
+    for b in range(budget_b + 1):
+        if dp[b] > best_v:
+            best_v = dp[b]
+            best_b = b
+    return pick[best_b]
+
+def _render_selected(root: _Node, selected: set[int]) -> str:
+    lines: list[str] = []
+
+    def emit(node: _Node) -> None:
+        if node.idx not in selected:
+            return
+        lines.append(node.line)
+        for child in node.children:
+            emit(child)
+
+    emit(root)
+    return "\n".join(lines)
+
+def reveal(root_path: str, task: str, budget_chars: int = _BUDGET_CHARS) -> str:
+    """Select an ancestor-closed initial workspace view using character buckets."""
+    if budget_chars < 0:
+        raise ValueError("budget_chars must be nonnegative")
+    tokens = _o0_token_set(task)
+    w_data, w_code = _task_type_weights(task)
+    tree = _build_tree(root_path, tokens, w_data, w_code)
+    selected = _subtree_knapsack(tree, budget_chars // _BUCKET_CHARS)
+    return _render_selected(tree, selected)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Select a budgeted initial workspace observation.")
+    parser.add_argument("workspace")
+    parser.add_argument("--task", required=True)
+    parser.add_argument("--budget-chars", type=int, default=_BUDGET_CHARS)
+    args = parser.parse_args()
+    print(reveal(args.workspace, args.task, args.budget_chars))
+
+
+if __name__ == "__main__":
+    main()

agentic_sigma_reveal-0.2.0/sigma_reveal_mcp.py

@@ -0,0 +1,57 @@
+import argparse
+import os
+from pathlib import Path
+from typing import Any
+
+from mcp.server import MCPServer
+
+from sigma_reveal import _MAX_DEPTH, reveal
+from sigma_reveal_reference import BIBTEX, METHOD
+
+
+def validate_workspace(root: Path) -> None:
+    if not root.is_dir():
+        raise ValueError('workspace must be an existing directory')
+    for directory, dirs, files in os.walk(root):
+        depth = len(Path(directory).relative_to(root).parts)
+        if depth >= _MAX_DEPTH:
+            dirs.clear()
+            continue
+        for name in dirs + files:
+            path = Path(directory) / name
+            if path.is_symlink() or not (path.is_dir() or path.is_file()):
+                raise ValueError('MCP workspace must contain only regular files and directories')
+
+
+def create_server(workspace: Path) -> MCPServer:
+    root = workspace.resolve(strict=True)
+    server = MCPServer('Sigma-Reveal workspace context')
+
+    @server.tool(structured_output=True)
+    def select_workspace_context(task: str, budget_chars: int = 2400) -> dict[str, Any]:
+        """Select a static initial workspace view and return the method's original paper reference."""
+        validate_workspace(root)
+        return {'context': reveal(str(root), task, budget_chars), 'method': METHOD}
+
+    @server.tool(structured_output=True)
+    def describe_method() -> dict[str, Any]:
+        """Describe Sigma-Reveal's initial workspace selection method, scope, and original BibTeX."""
+        return METHOD
+
+    @server.resource('sigma-reveal://reference', mime_type='text/plain')
+    def reference() -> str:
+        """Original paper BibTeX for Sigma-Reveal workspace observation."""
+        return BIBTEX
+
+    return server
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description='Local Sigma-Reveal MCP server')
+    parser.add_argument('--workspace', type=Path, required=True)
+    args = parser.parse_args()
+    create_server(args.workspace).run()
+
+
+if __name__ == '__main__':
+    main()

agentic_sigma_reveal-0.2.0/sigma_reveal_reference.py

@@ -0,0 +1,14 @@
+BIBTEX = '@article{su2026structuredactioncredit,\n  title = {Learning CLI Agents with Structured Action Credit under Selective Observation},\n  author = {Su, Haoyang and Wen, Ying},\n  year = {2026},\n  journal = {arXiv preprint arXiv:2605.08013},\n  doi = {10.48550/arXiv.2605.08013},\n  url = {https://arxiv.org/abs/2605.08013}\n}\n'
+
+PAPER_URL = "https://arxiv.org/abs/2605.08013"
+
+METHOD = {
+    "name": "Sigma-Reveal",
+    "purpose": "Task-conditioned initial workspace observation for CLI agent harnesses",
+    "selection": "Exact ancestor-closed tree knapsack with task-name, depth, and extension scores",
+    "budget_unit": "characters, rounded into 16-character line-cost buckets",
+    "scope": "Static initial observation before the first action; downstream effects require evaluation",
+    "paper_url": PAPER_URL,
+    "paper_section": "3.2",
+    "bibtex": BIBTEX,
+}

agentic_sigma_reveal-0.2.0/tests/test_mcp.py

@@ -0,0 +1,35 @@
+import tempfile
+import unittest
+from pathlib import Path
+
+from mcp import Client
+
+from sigma_reveal import reveal
+from sigma_reveal_mcp import create_server
+from sigma_reveal_reference import BIBTEX
+
+
+class MCPTests(unittest.IsolatedAsyncioTestCase):
+    async def test_selection_and_reference(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            (root / 'sales.csv').write_text('year,revenue\n2025,12\n')
+            async with Client(create_server(root)) as client:
+                result = await client.call_tool('select_workspace_context', {'task': 'Analyze sales.csv', 'budget_chars': 80})
+                self.assertFalse(result.is_error)
+                self.assertEqual(result.structured_content['context'], reveal(directory, 'Analyze sales.csv', 80))
+                self.assertEqual(result.structured_content['method']['bibtex'], BIBTEX)
+                reference = await client.read_resource('sigma-reveal://reference')
+                self.assertEqual(reference.contents[0].text, BIBTEX)
+
+    async def test_rejects_symlink(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            (root / 'link').symlink_to(root)
+            async with Client(create_server(root)) as client:
+                result = await client.call_tool('select_workspace_context', {'task': 'Inspect files'})
+                self.assertTrue(result.is_error)
+
+
+if __name__ == '__main__':
+    unittest.main()

agentic_sigma_reveal-0.2.0/tests/test_selection.py

@@ -0,0 +1,44 @@
+import itertools
+import tempfile
+import unittest
+from pathlib import Path
+
+from sigma_reveal import _Node, _subtree_knapsack, reveal
+
+
+class SelectionTests(unittest.TestCase):
+    def test_optimality_and_ancestor_closure(self):
+        nodes = [_Node(i, str(i), 0, True, str(i), cost, score)
+                 for i, (cost, score) in enumerate([(1, 1), (2, 3), (1, 5), (3, 4)])]
+        nodes[0].children = [nodes[1], nodes[3]]
+        nodes[1].children = [nodes[2]]
+        for budget in range(9):
+            selected = _subtree_knapsack(nodes[0], budget)
+            feasible_scores = [0]
+            for flags in itertools.product((False, True), repeat=4):
+                subset = {i for i, flag in enumerate(flags) if flag}
+                if subset and 0 not in subset:
+                    continue
+                if 2 in subset and 1 not in subset:
+                    continue
+                if sum(nodes[i].cost_b for i in subset) <= budget:
+                    feasible_scores.append(sum(nodes[i].mu for i in subset))
+            self.assertLessEqual(sum(nodes[i].cost_b for i in selected), budget)
+            self.assertEqual(sum(nodes[i].mu for i in selected), max(feasible_scores))
+            self.assertTrue(2 not in selected or 1 in selected)
+
+    def test_rendered_budget_and_determinism(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            (root / 'data').mkdir()
+            (root / 'data/sales.csv').write_text('year,revenue\n2025,12\n')
+            (root / 'run.py').write_text('print("hello")\n')
+            for budget in (0, 15, 16, 32, 80, 2400):
+                result = reveal(directory, 'Analyze sales.csv', budget)
+                self.assertLessEqual(len(result), budget)
+                self.assertEqual(result, reveal(directory, 'Analyze sales.csv', budget))
+            self.assertIn('sales.csv', reveal(directory, 'Analyze sales.csv'))
+
+
+if __name__ == '__main__':
+    unittest.main()