code-search-cli 0.1.0__py3-none-any.whl

code_retrieval/resources/code-search/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: code-search
+description: Task-aware local code retrieval that returns concise, explainable evidence. Use when locating implementation for a bug or feature, tracing lifecycle or structural relationships, gathering relevant code context for an engineering task, or inspecting code at a historical Git revision.
+---
+
+# Code Search
+
+Use the `code-search` CLI to retrieve a small, auditable evidence bundle before reading broad parts of
+a repository.
+
+For a large repository, `code-search index --repo <path>` can prewarm the persistent index. Normal
+`retrieve` calls also refresh it incrementally, so prewarming is optional.
+
+## Workflow
+
+1. Describe the engineering task, including the failure, component, and expected behavior when known.
+2. Retrieve a ranked evidence set:
+
+```bash
+code-search retrieve \
+  --repo /absolute/path/to/repository \
+  --task "Fix startup events that are published before subscribers register" \
+  --format json
+```
+
+3. Inspect each result's path, line range, reasons, and token cost. Read the highest-value source spans
+   directly before editing. Treat each `required repair site:` reason as a separate actionable
+   responsibility; verify every marked production file before deciding the final change set.
+4. Expand a known anchor only when the task needs its enclosing unit, siblings, or references:
+
+```bash
+code-search expand \
+  --repo /absolute/path/to/repository \
+  --path src/main/java/example/Service.java \
+  --line 120 \
+  --relation references
+```
+
+5. Use `rg` instead when the task requires every exact literal occurrence. Treat retrieved evidence as
+   a navigation aid, then validate conclusions against source code and tests.
+
+## Constraints
+
+- Prefer distinct evidence roles over near-duplicate snippets.
+- Do not claim that a missing result proves code is absent.
+- The CLI is read-only and must not be used as evidence that a proposed patch is correct; run relevant
+  tests after making changes.

code_retrieval/resources/code-search/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Code Search"
+  short_description: "Find concise evidence for an engineering task"
+  default_prompt: "Use $code-search to find the smallest verifiable code evidence set for this task."

code_retrieval/structure.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+import re
+
+from .models import Section, SourceFile
+
+
+JAVA_METHOD_RE = re.compile(
+    r"(?:^|\s)(?:public|protected|private|static|final|synchronized|abstract|native|default|strictfp|\s)+"
+    r"(?:<[^{>]+>\s+)?(?:[\w$.<>\[\],?]+\s+)?([A-Za-z_$][\w$]*)\s*\([^;{}]*\)\s*"
+    r"(?:throws\s+[^{]+)?\{\s*$"
+)
+PYTHON_DEF_RE = re.compile(r"^\s*(?:async\s+)?def\s+([A-Za-z_]\w*)\s*\(")
+JS_FUNCTION_RE = re.compile(
+    r"^\s*(?:export\s+)?(?:async\s+)?(?:function\s+([A-Za-z_$][\w$]*)|"
+    r"(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=.*=>)"
+)
+CONTROL_NAMES = {"if", "for", "while", "switch", "catch", "try", "do", "synchronized"}
+
+
+def sections_for(source: SourceFile) -> list[Section]:
+    suffix = source.path.rsplit(".", 1)[-1].lower() if "." in source.path else ""
+    if suffix in {"java", "kt", "kts", "scala"}:
+        sections = _brace_sections(source, JAVA_METHOD_RE)
+    elif suffix == "py":
+        sections = _python_sections(source)
+    elif suffix in {"js", "jsx", "ts", "tsx"}:
+        sections = _brace_sections(source, JS_FUNCTION_RE)
+    else:
+        sections = []
+    return sections or _window_sections(source)
+
+
+def containing_section(source: SourceFile, line: int, sections: list[Section] | None = None) -> Section:
+    sections = sections if sections is not None else sections_for(source)
+    matches = [section for section in sections if section.start_line <= line <= section.end_line]
+    if matches:
+        return min(matches, key=lambda item: item.end_line - item.start_line)
+    lines = source.content.splitlines()
+    start = max(1, line - 20)
+    end = min(len(lines), line + 20)
+    return _make_section(source.path, "context", "window", start, end, lines)
+
+
+def _brace_sections(source: SourceFile, pattern: re.Pattern[str]) -> list[Section]:
+    lines = source.content.splitlines()
+    sections: list[Section] = []
+    index = 0
+    while index < len(lines):
+        header_start = index
+        while header_start > 0 and lines[header_start - 1].lstrip().startswith("@"):
+            header_start -= 1
+        combined = lines[index].strip()
+        cursor = index
+        while cursor + 1 < len(lines) and "{" not in combined and len(combined) < 1200:
+            cursor += 1
+            combined += " " + lines[cursor].strip()
+        match = pattern.search(combined)
+        if not match:
+            index += 1
+            continue
+        name = next((group for group in match.groups() if group), "anonymous")
+        if name in CONTROL_NAMES:
+            index += 1
+            continue
+        depth = 0
+        seen_open = False
+        end = cursor
+        for end in range(cursor, len(lines)):
+            depth += lines[end].count("{") - lines[end].count("}")
+            seen_open = seen_open or "{" in lines[end]
+            if seen_open and depth <= 0:
+                break
+        sections.append(_make_section(source.path, name, "method", header_start + 1, end + 1, lines))
+        index = max(index + 1, end + 1)
+    return sections
+
+
+def _python_sections(source: SourceFile) -> list[Section]:
+    lines = source.content.splitlines()
+    starts: list[tuple[int, str, int]] = []
+    for index, line in enumerate(lines):
+        match = PYTHON_DEF_RE.match(line)
+        if match:
+            starts.append((index, match.group(1), len(line) - len(line.lstrip())))
+    sections: list[Section] = []
+    for position, (start, name, indent) in enumerate(starts):
+        end = len(lines)
+        for later, _, later_indent in starts[position + 1 :]:
+            if later_indent <= indent:
+                end = later
+                break
+        sections.append(_make_section(source.path, name, "function", start + 1, end, lines))
+    return sections
+
+
+def _window_sections(source: SourceFile, size: int = 48, overlap: int = 12) -> list[Section]:
+    lines = source.content.splitlines()
+    if not lines:
+        return []
+    sections = []
+    step = size - overlap
+    for start_index in range(0, len(lines), step):
+        end_index = min(len(lines), start_index + size)
+        sections.append(
+            _make_section(source.path, f"lines-{start_index + 1}-{end_index}", "window", start_index + 1, end_index, lines)
+        )
+        if end_index == len(lines):
+            break
+    return sections
+
+
+def _make_section(path: str, name: str, kind: str, start: int, end: int, lines: list[str]) -> Section:
+    content = "\n".join(lines[start - 1 : end])
+    return Section(path, name, kind, start, end, content)

code_search_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,287 @@
+Metadata-Version: 2.4
+Name: code-search-cli
+Version: 0.1.0
+Summary: Task-aware, evidence-oriented local code retrieval
+Author: Code Search contributors
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/quguai/code-search
+Project-URL: Repository, https://github.com/quguai/code-search
+Project-URL: Issues, https://github.com/quguai/code-search/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Dynamic: license-file
+
+<div align="center">
+  <a href="https://github.com/quguai/code-search">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/quguai/code-search/main/assets/brand-dark.png" />
+      <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/quguai/code-search/main/assets/brand-light.png" />
+      <img src="https://raw.githubusercontent.com/quguai/code-search/main/assets/brand-light.png" alt="CodeSearch" width="600" />
+    </picture>
+  </a>
+  <p><strong>Task-aware code search for coding agents</strong></p>
+  <p>Accurate evidence. Smaller context. No runtime model.</p>
+</div>
+
+<p align="center">
+  <a href="https://github.com/quguai/code-search/actions/workflows/ci.yml"><img alt="CI" src="https://img.shields.io/github/actions/workflow/status/quguai/code-search/ci.yml?branch=main&amp;style=flat-square" /></a>
+  <a href="https://github.com/quguai/code-search/blob/main/LICENSE"><img alt="Apache-2.0 license" src="https://img.shields.io/github/license/quguai/code-search?style=flat-square" /></a>
+  <img alt="Python 3.11+" src="https://img.shields.io/badge/Python-3.11%2B-3776AB?style=flat-square&amp;logo=python&amp;logoColor=white" />
+  <img alt="Codex skill included" src="https://img.shields.io/badge/Codex-skill_included-5B47D6?style=flat-square" />
+  <img alt="Experimental status" src="https://img.shields.io/badge/status-experimental-D97706?style=flat-square" />
+</p>
+
+<p align="center">
+  <strong>English</strong> | <a href="https://github.com/quguai/code-search/blob/main/README.zh-CN.md">简体中文</a> | <a href="https://github.com/quguai/code-search/blob/main/README.ja-JP.md">日本語</a> | <a href="https://github.com/quguai/code-search/blob/main/README.ko-KR.md">한국어</a> | <a href="https://github.com/quguai/code-search/blob/main/README.ru-RU.md">Русский</a>
+</p>
+
+---
+
+Code Search is a task-aware retrieval CLI for coding agents. It returns a concise, verifiable set of
+source evidence for an engineering task—not only a list of similar snippets.
+
+The current release is an independently implemented, no-runtime-model MVP. It can read a working tree
+or any Git revision and returns source locations, ranking reasons, structural evidence roles, and
+payload statistics.
+
+> Search less. Hand the agent the evidence it needs to act.
+
+## Quick start
+
+### Install from this checkout
+
+The complete local flow works today:
+
+```bash
+cd /path/to/code-search
+uv tool install .
+code-search install
+```
+
+`code-search install` installs the bundled `code-search` skill into Codex. Restart Codex after the
+command so it can discover the skill. The installer is idempotent and refuses to overwrite a locally
+modified skill unless `--force` is supplied.
+
+After the first PyPI release, the first command becomes:
+
+```bash
+uv tool install code-search-cli
+code-search install
+```
+
+The PyPI distribution name (`code-search-cli`) and CLI entry point (`code-search`) are ready, but this
+repository has not been published to PyPI yet.
+
+### Retrieve evidence for a task
+
+```bash
+code-search retrieve \
+  --repo /path/to/repository \
+  --task "Fix dependency injection order so startup events are not missed"
+```
+
+The command is read-only. It does not check out revisions, modify the target repository, or create an
+index inside it. It incrementally maintains a per-user SQLite index under the operating-system cache
+directory; use `code-search clean` to remove the cached source snapshot and derived metadata.
+
+## What you get
+
+- A concise, de-duplicated evidence set instead of an unbounded list of matches.
+- Source locations, scores, inclusion reasons, and estimated token cost for every result.
+- Lightweight structural obligations for lifecycle, event, dependency-ordering, and test evidence.
+- Direct reads from a working tree or historical Git revision without changing the checkout.
+- A persistent incremental index that reuses unchanged source terms and structural boundaries.
+- Java, Python, JavaScript, and TypeScript structural extraction with no runtime model dependency.
+- A bundled Codex skill that teaches the agent when to retrieve, expand, or fall back to exact `rg`.
+
+## CLI
+
+Read a historical revision:
+
+```bash
+code-search retrieve \
+  --repo /path/to/repository \
+  --ref HEAD~1 \
+  --task "Resolve NullPointerException in scheduled dump" \
+  --format json
+```
+
+Expand a known anchor to its enclosing unit, siblings, or references:
+
+```bash
+code-search expand \
+  --repo /path/to/repository \
+  --path src/main/java/example/Service.java \
+  --line 120 \
+  --relation enclosing
+```
+
+Manage the Codex skill:
+
+```bash
+code-search install
+code-search uninstall
+```
+
+Prewarm, inspect, or remove the per-repository index:
+
+```bash
+code-search index --repo /path/to/repository
+code-search status --repo /path/to/repository
+code-search clean --repo /path/to/repository
+```
+
+## Benchmarks
+
+The primary benchmark uses `NDCG@10`, `Recall@10`, `MRR@10`, latency, and Top-10 payload size. The
+local shared subset contains 61 queries over pinned revisions of Gson, Apache Commons Lang, and
+Jackson Databind. Semble's published 1,251-query results are kept in a separate table and are not
+presented as a local rerun.
+
+<!-- benchmark-results:start -->
+#### Local four-axis scorecard
+
+![Local scorecard for ranking, Top-10 recall, latency, and payload](https://raw.githubusercontent.com/quguai/code-search/main/assets/benchmark-quality-speed.png)
+
+### Local shared Java subset
+
+| Method | NDCG@10 | Recall@10 | MRR@10 | Warm p50 | Top-10 payload |
+|---|---:|---:|---:|---:|---:|
+| Semble | **0.8250** | **0.9754** | **0.7852** | 4.25 ms | 1,803 tok |
+| code-review-graph | 0.7634 | 0.8607 | 0.7670 | 103.30 ms | 16,162 tok |
+| Code Search MVP | 0.7217 | 0.8525 | 0.6970 | 38.08 ms | 2,490 tok |
+| BM25 | 0.5686 | 0.7623 | 0.5398 | **0.72 ms** | **1,752 tok** |
+| probe | 0.2044 | 0.4262 | 0.1453 | 1,764.40 ms | 5,537 tok |
+| ripgrep | 0.1977 | 0.2377 | 0.1904 | 30.84 ms | 28,605 tok |
+
+### Published full-suite reference (not a local rerun)
+
+These values are reported by Semble for its 1,251-query, 63-repository, 19-language benchmark.
+
+| Method | NDCG@10 | Cold first result | Model size |
+|---|---:|---:|---:|
+| CodeRankEmbed Hybrid | 0.8617 | 57.29 s | 137M |
+| semble | 0.8544 | 264.09 ms | 16M |
+| CodeRankEmbed | 0.7648 | 57.29 s | 137M |
+| ColGREP | 0.6925 | 5.87 s | 16M |
+| BM25 | 0.6730 | 262.62 ms | no model |
+| grepai | 0.5610 | 35.00 s | 137M |
+| probe | 0.3870 | 207.10 ms | no model |
+| ripgrep | 0.1260 | 12.08 ms | no model |
+<!-- benchmark-results:end -->
+
+Regenerate the scorecard and synchronize the measured JSON values into both READMEs:
+
+```bash
+uv run --no-project --with matplotlib python scripts/publish_shared_benchmark.py
+```
+
+This command does not rerun the benchmark or publish a package. See the
+[shared benchmark methodology](https://github.com/quguai/code-search/blob/main/benchmarks/shared-java/README.md),
+[raw local results](https://github.com/quguai/code-search/blob/main/benchmarks/shared-java/RESULTS.json), and
+[published-reference provenance](https://github.com/quguai/code-search/blob/main/benchmarks/shared-java/PUBLISHED_REFERENCE.json).
+
+The unit test suite creates only temporary synthetic repositories. The shared benchmark uses public,
+pinned Gson, Apache Commons Lang, and Jackson Databind revisions with Semble's public annotations.
+Machine-local and private development tasks are deliberately excluded from the public repository.
+
+## How it differs from Semble and code-review-graph
+
+The projects overlap, but optimize different parts of an agent workflow. This comparison describes
+their public product shape; it is not a claim that one implementation dominates every task.
+
+| | Code Search | Semble | code-review-graph |
+|---|---|---|---|
+| Primary job | Assemble task-relevant, explainable evidence | Find relevant code chunks quickly | Persist code relations for review, impact, and multi-hop exploration |
+| Result shape | Evidence bundle with source, reason, score, and structural role | Compact ranked code snippets | Graph nodes, relations, traversals, and review reports |
+| Retrieval | Lexical and task-aware structural retrieval; no runtime model today | Code-aware chunks, semantic retrieval, BM25, fusion, and reranking | Structural graph plus full-text/vector hybrid search |
+| Structure/history | Persistent incremental local index, lightweight expansion, and direct reads from any Git revision | Similar-chunk retrieval and cached working-tree indexes | Persistent incremental graph, callers, flows, communities, and impact analysis |
+| Onboarding | CLI plus a bundled Codex skill installer | CLI installer for MCP, instructions, and search sub-agents across multiple agents | CLI, MCP, daemon, GitHub Action, and review workflows |
+| Best fit today | Explainable task-evidence experiments | Fast general-purpose natural-language code search | Review and durable multi-hop structural questions |
+
+Semble still has the broader onboarding path. Its `install` command can configure MCP, generated
+instructions, or a dedicated sub-agent across several coding agents. `code-search install` currently
+installs one Codex skill. Code Search intentionally uses CLI + skill as its primary interface; an MCP
+server is optional, not a prerequisite.
+
+### Current advantages
+
+- **Task roles, not only similarity.** Lifecycle, registration, publication, ordering, and test
+  evidence are represented separately instead of returning only one cluster of similar chunks.
+- **Missing-behavior evidence.** For callback tasks, structurally similar sibling methods can expose
+  an expected publication step that is absent from the target path, instead of rewarding only code
+  that already contains the queried behavior.
+- **Causal repair sets.** Startup-order tasks can connect a publisher, a lazily initialized static
+  subscriber, and the lifecycle owner whose dependency declaration must change, marking each
+  independently actionable production file.
+- **Auditable evidence.** Each unit includes its location, reason, score, and estimated token cost.
+- **Historical and no-model operation.** It can inspect a Git revision without checkout and has no
+  runtime model dependency.
+- **Smaller output than the current graph adapter.** On the shared subset, Code Search returns a
+  2,490-token Top-10 payload versus 16,162 tokens for code-review-graph.
+
+### Where competitors still lead
+
+Semble leads this MVP on ranking quality, token efficiency, warm latency, and integration breadth.
+code-review-graph provides deeper persistent relations, incremental graph maintenance, and review
+automation. Code Search does not currently claim an overall win over either project.
+
+## How it works
+
+The engine incrementally caches source terms and structural boundaries, splits identifiers, expands
+engineering aliases, scores paths and content, identifies task-specific structural obligations,
+contrasts related sibling methods when a callback path is missing expected behavior, detects missing
+subscriber-initialization and dependency edges, focuses long methods into query-aware windows, expands
+selected anchors, and packs non-duplicate evidence into a ranked result set. The differentiating thesis is:
+
+> Return not only similar code, but the evidence subgraph required to answer the engineering task.
+
+This is currently a transparent lexical/structural baseline. Independently implemented dense retrieval
+and stronger parsers remain future work.
+
+## Documentation
+
+- [Competitive analysis](https://github.com/quguai/code-search/blob/main/docs/competitive-analysis.md)
+- [Product thesis and proposed architecture](https://github.com/quguai/code-search/blob/main/docs/product-thesis.md)
+- [MVP implementation](https://github.com/quguai/code-search/blob/main/docs/implementation.md)
+- [Evaluation plan](https://github.com/quguai/code-search/blob/main/docs/evaluation-plan.md)
+- [Open benchmark and adapters](https://github.com/quguai/code-search/blob/main/docs/benchmarking.md)
+- [Shared Java benchmark](https://github.com/quguai/code-search/blob/main/benchmarks/shared-java/README.md)
+- [PyPI release process](https://github.com/quguai/code-search/blob/main/docs/releasing.md)
+
+## Current gaps
+
+- **P0 — public held-out validation:** publish at least 30 untouched, license-compatible tasks with
+  executable patch tests and repeated model runs.
+- **P1 — retrieval quality:** add independently implemented optional dense retrieval and stronger
+  AST/symbol parsers.
+- **P1 — onboarding breadth:** add safe CLI/skill installers for more coding agents. Consider MCP only
+  if a resident index or structured tool discovery provides a measured benefit over CLI invocation.
+- **P2 — distribution:** publish to PyPI and ship signed standalone binaries. Until publication,
+  `uv tool install code-search-cli` cannot install this project from the public registry.
+
+## Status and independent implementation
+
+This is a testable experimental MVP, not a production release. It reaches `0.7217 NDCG@10` on the
+61-query shared Java subset versus Semble at `0.8250`; Recall@10 is `0.8525`, and warm query p50 is
+38.08 ms. These public results measure retrieval, not executable patch success, and are not a held-out
+production claim.
+
+The project is inspired by [Semble](https://github.com/MinishLab/semble) and
+[code-review-graph](https://github.com/tirth8205/code-review-graph), which are used as public baselines.
+It does not copy or rewrite their source, tests, prompts, documentation, interfaces, or distinctive
+command vocabulary. The implementation and bundled Codex skill are independently designed around this
+project's task-evidence workflow.
+
+## License
+
+Licensed under the [Apache License 2.0](https://github.com/quguai/code-search/blob/main/LICENSE). Semble and code-review-graph are independent projects;
+their code is not included here.

code_search_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+code_retrieval/__init__.py,sha256=zNqqZe91zhRnR4onrqkRk9iW7xxG60wiZeQmTgZ8awQ,220
+code_retrieval/__main__.py,sha256=k1ocEWawweo1qCJWNFAAvyxz3tcY13dzvCenHszij30,48
+code_retrieval/cli.py,sha256=_ArAExiKa05vHow7PRUNItnF4Hzt9t372mYfkSNOWao,5921
+code_retrieval/engine.py,sha256=xmiEVGp0rLhAbI0VzBfhe4uBtkrr_47aiOI9nkjiFg0,31539
+code_retrieval/index_store.py,sha256=pXAeliFO3kwuyGogXlQF7uNHWGqoyyztsrUIBmQvwT4,10903
+code_retrieval/installer.py,sha256=l4wdDk3jSe2EQT4vGZhZvY8oCIEJofprUyoy6XIOi9s,2415
+code_retrieval/models.py,sha256=kLQ_Md8fBWOnDkQa4CGUF886wBbv_8vp1b7SVJMJsGw,2341
+code_retrieval/query.py,sha256=xjcBTEdjz51RyoIj0wtYR-WMI9_2nXIJ8P7Xzu_D2jo,2455
+code_retrieval/repository.py,sha256=Og3gzluSB3CS4_6OhyQF-hHU75v855Fa0xN4U62pH78,5749
+code_retrieval/structure.py,sha256=6Fwo1h-oaIxY9gSowu0LKhD6UL4WIkZpVkPr1euQHCY,4497
+code_retrieval/resources/code-search/SKILL.md,sha256=VZiSxZZAhr62hEaTFHm99gWF7KGYsquHGsgeJHq5sfs,1955
+code_retrieval/resources/code-search/agents/openai.yaml,sha256=Qz6AxMi9Wg0ZxqO-xwsv2En-SDQ6LBQ4twi8pp_0vBs,212
+code_search_cli-0.1.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+code_search_cli-0.1.0.dist-info/licenses/NOTICE,sha256=b1SkI7tJw19Je1SNLP7eNDWpwxD7A-TsI6QiYat9HVE,270
+code_search_cli-0.1.0.dist-info/METADATA,sha256=TaexvHUtUL8c0VJoubGSncTxl_YrXIZiUX6Zal4cTIM,14660
+code_search_cli-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+code_search_cli-0.1.0.dist-info/entry_points.txt,sha256=Y4u1GuLbinsDr-jdhyQZF9XFEdnsco_byL8NTrDYp7w,56
+code_search_cli-0.1.0.dist-info/top_level.txt,sha256=G2fxsJkpCt-QxmOlHVKR-XtsH9IZnM1lAhfurXOqsDw,15
+code_search_cli-0.1.0.dist-info/RECORD,,

code_search_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

code_search_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+code-search = code_retrieval.cli:main