@polderlabs/bizar-omp 0.2.0 → 0.3.0

package/skills/omp-native-development/references/tools-and-capabilities.md

@@ -0,0 +1,59 @@
+# Tool and subsystem research map
+
+Snapshot: `dbf3afad4894bde827d90f965e77b3fe1c5a95e5`. This is a navigation and verification guide, not a claim that every tool has been runtime-qualified.
+
+## Contents
+1. Use the live contract
+2. Tool families
+3. Cross-cutting subsystems
+4. Extending coverage
+5. Sources
+
+## 1. Use the live contract
+
+Do not maintain a guessed universal list of tool arguments. Native availability and schemas depend on settings, mode, provider support and discovery. For a tool change, read its pinned `docs/tools/<name>.md`, then follow its named implementation and model-facing prompt. Inspect the active schema and a representative result from the target runtime.
+
+For code-mode/eval workflows, identify whether the tool is exposed directly, through a bridge, or as a helper inside a kernel. Intercepting one public tool call does not prove every nested effect is covered. Preserve native argument validation, approvals, artifact conventions and result bookkeeping.
+
+## 2. Tool families
+
+| Family | Indexed documents | Required investigation |
+| --- | --- | --- |
+| File and text | tools/read.md, write.md, edit.md, glob.md, grep.md | Paths, native internal URLs, result truncation, edit semantics and side effects |
+| AST and LSP | tools/ast-grep.md, ast-edit.md, lsp.md; lsp-config.md | Supported edit operations, diagnostics, code actions and write-through behavior |
+| Execution | tools/bash.md, eval.md; bash-tool-runtime.md; python-repl.md | Shell/kernel lifecycle, backgrounding, cancellation, process and filesystem access |
+| Delegation | tools/task.md, hub.md; agent-hub.md; task-agent-discovery.md | Dynamic schemas, role routing, jobs, messaging, revival and structured results |
+| Browser/computer | tools/browser.md, computer.md; computer-use.md | Mode-specific interfaces, session ownership, user state and destructive actions |
+| Research | tools/web_search.md, github.md | Provider configuration, source attribution, result grounding and permissions |
+| Workflow state | tools/todo.md, checkpoint.md, rewind.md, new-context.md | Native state ownership, approval/plan interaction and history semantics |
+| Memory/learning | tools/recall.md, retain.md, reflect.md, learn.md, memory_edit.md, context-notes.md | Backend behavior, scope, persistence, deletion and retrieval boundaries |
+| Skills | tools/manage_skill.md; skills.md | Authored versus managed content, discovery, updates and provenance |
+| Specialized | tools/debug.md, security_scan.md, generate_image.md, tts.md | Actual runtime dependencies and exact target support |
+
+The table maps documentation paths, not guaranteed enabled tools. A tool's existence in the repository does not make it active in all user sessions or supported by every model.
+
+## 3. Cross-cutting subsystems
+
+For MCP, read configuration, transports, lifecycle and tool-authoring documents together. Establish who owns connections, whether children proxy parent tools, how refresh notifications work, and how errors/cancellation cross the bridge. Do not expose an unnecessary Bizar MCP server for functions already implemented in-process.
+
+For memory, use the native backend/runtime interface where available. Do not modify another backend's internal database and call that integration. Distinguish workflow evidence, authored skills, learned skills and general memory; they have different provenance and acceptance roles.
+
+For compaction, read the native method and artifact contracts before deciding what Bizar must checkpoint. Store authoritative workflow evidence outside expendable prompt summaries, with stable references. Do not disable native compaction merely to avoid implementing resume.
+
+For provider integration, use the model configuration and compatibility references plus the exact provider implementation. Tool schemas, image encoding, context accounting, caching and retry safety depend on the transport. Model/endpoint names alone do not establish capabilities.
+
+For TUI, follow the exact target's exported components. The main/release split at this pin is particularly relevant to UI imports. Prefer optional presentation that does not control workflow correctness.
+
+For native bindings and isolation, follow the specific backend and build contracts. Do not assume Linux, macOS and Windows have identical clone semantics, dependencies or containment. A portable TypeScript wrapper still depends on native runtime behavior.
+
+For remote/collaborative use, follow `rpc.md`, `collab.md` and the package-specific references. Keep remote/client capability differences explicit; do not turn a terminal extension into an unauthenticated server by adding an ad hoc HTTP listener.
+
+## 4. Extending coverage
+
+The docs index covers all enumerated root Markdown pages, including tool-conversation format notes, native architecture, marketplace authoring and internal runtime references. Some feature-specific detail lives in package READMEs, tests, examples or issues. Retrieve those at the same target revision and add their identifiers to the implementation evidence, not to an unsourced prose assertion.
+
+When a source is absent, contradictory or unsupported by an accessible callsite, record UNKNOWN and design a focused probe. For genuinely new APIs, put proposed names in a proposal section and never present them as already available native methods.
+
+## 5. Sources
+
+Use [official-docs-index.md](official-docs-index.md) for immutable per-page URLs and research status. The index was generated from the complete enumerated `docs/` tree at the research commit; supporting Git blob identities are in [source-manifest.json](source-manifest.json).

package/skills/omp-native-development/scripts/audit_role_config.py

@@ -0,0 +1,167 @@
+#!/usr/bin/env python3
+"""Static Bizar role-profile lint, NOT an OMP resolver or availability test.
+
+Input: effective JSON from `omp config list --json`, or a nested JSON profile.
+No YAML parsing, environment expansion, credentials, providers or model calls.
+Native resolution/authentication and live-agent tests remain mandatory.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+import re
+import sys
+from typing import Any
+
+BUILTINS = {"default", "smol", "slow", "vision", "plan", "commit", "tiny", "task", "advisor"}
+TIERS = {"inherit", "none", "auto", "default", "flex", "scale", "priority"}
+ROLE_ALIAS = re.compile(r"^(?:@|pi/)([^,\r\n]+?)(?::(?:off|minimal|low|medium|high|xhigh|max|auto))?$")
+PLACEHOLDER = re.compile(r"REPLACE_|YOUR_|<[^>]+>", re.I)
+
+
+def get_value(config: dict[str, Any], key: str, default: Any) -> Any:
+    if key in config:
+        value = config[key]
+        if isinstance(value, dict) and "type" in value and ("value" in value or value.get("redacted")):
+            return value.get("value", default)
+        return value
+    value: Any = config
+    for part in key.split("."):
+        if not isinstance(value, dict) or part not in value:
+            return default
+        value = value[part]
+    return value
+
+
+def referenced_roles(value: str | list[str]) -> list[str]:
+    patterns = value if isinstance(value, list) else [value]
+    result = []
+    for item in patterns:
+        for pattern in item.split(","):
+            pattern = pattern.strip()
+            if pattern == "*" or re.fullmatch(r"\*:(off|minimal|low|medium|high|xhigh|max|auto)", pattern):
+                result.append("default")
+            elif (match := ROLE_ALIAS.fullmatch(pattern)):
+                result.append(match.group(1))
+    return result
+
+
+def audit(config: dict[str, Any], required: list[str], known_agents: list[str] | None) -> dict[str, Any]:
+    errors: list[dict[str, str]] = []
+    warnings: list[dict[str, str]] = []
+    def error(code: str, message: str) -> None:
+        errors.append({"code": code, "message": message})
+    def warning(code: str, message: str) -> None:
+        warnings.append({"code": code, "message": message})
+    roles = get_value(config, "modelRoles", {})
+    overrides = get_value(config, "task.agentModelOverrides", {})
+    tiers = get_value(config, "task.agentServiceTierOverrides", {})
+    for label, value in (("modelRoles", roles), ("task.agentModelOverrides", overrides), ("task.agentServiceTierOverrides", tiers)):
+        if not isinstance(value, dict):
+            error("EXPECTED_RECORD", f"{label} must be a mapping for this profile")
+    if errors:
+        return {"static_ok": False, "native_resolution_tested": False, "errors": errors, "warnings": warnings}
+    if len(roles) > 512:
+        error("PROFILE_SIZE_LIMIT", "This static lint supports at most 512 explicitly configured roles")
+        return {"static_ok": False, "native_resolution_tested": False, "errors": errors, "warnings": warnings}
+    graph: dict[str, list[str]] = {}
+    for name, selector in roles.items():
+        if not isinstance(name, str) or not name.strip():
+            error("INVALID_ROLE_NAME", "Role keys must be nonempty strings")
+            continue
+        if not isinstance(selector, str) or not selector.strip():
+            error("INVALID_ROLE_VALUE", f"Role {name!r} must use a nonempty selector string in this profile")
+            continue
+        if PLACEHOLDER.search(selector):
+            error("PLACEHOLDER", f"Role {name!r} still contains a template placeholder")
+        graph[name] = referenced_roles(selector)
+        for target in graph[name]:
+            if target not in BUILTINS and target not in roles:
+                error("UNCONFIGURED_ROLE", f"Role {name!r} references unconfigured custom role {target!r}")
+        if selector.startswith("pi/"):
+            warning("LEGACY_ALIAS", f"Role {name!r} uses the supported legacy alias prefix; prefer @ for new configuration")
+    visiting: set[str] = set()
+    visited: set[str] = set()
+    reported: set[str] = set()
+    def visit(name: str) -> None:
+        if name in visiting:
+            if name not in reported:
+                error("BIZAR_POLICY_CYCLE", f"Explicit role cycle through {name!r}; rejected by Bizar lint, not a claim that OMP always rejects cycles")
+                reported.add(name)
+            return
+        if name in visited:
+            return
+        visiting.add(name)
+        for target in graph.get(name, []):
+            if target in graph:
+                visit(target)
+        visiting.remove(name)
+        visited.add(name)
+    for name in graph:
+        visit(name)
+    for role in required:
+        if role not in roles and role not in BUILTINS:
+            error("MISSING_REQUIRED_ROLE", f"Required role {role!r} has no configured mapping")
+    for agent, selector in overrides.items():
+        values = [selector] if isinstance(selector, str) else selector
+        if not isinstance(values, list) or not values or any(not isinstance(v, str) or not v.strip() for v in values):
+            error("INVALID_AGENT_OVERRIDE", f"Agent override {agent!r} must contain nonempty selectors")
+            continue
+        if known_agents is not None and agent not in known_agents:
+            error("UNKNOWN_AGENT", f"Override {agent!r} is absent from the supplied discovered-agent names")
+        for target in referenced_roles(values):
+            if target not in BUILTINS and target not in roles:
+                error("UNCONFIGURED_ROLE", f"Agent override {agent!r} references unconfigured custom role {target!r}")
+        if any(PLACEHOLDER.search(v) for v in values):
+            error("PLACEHOLDER", f"Agent override {agent!r} contains a template placeholder")
+    for agent, tier in tiers.items():
+        if not isinstance(tier, str) or tier not in TIERS:
+            error("INVALID_SERVICE_TIER", f"Agent {agent!r} has an unsupported service-tier value")
+        if known_agents is not None and agent not in known_agents:
+            error("UNKNOWN_AGENT", f"Service-tier override {agent!r} is absent from supplied discovered-agent names")
+    for key in ("task.agentPrewalk", "task.agentAdvisor"):
+        value = get_value(config, key, {})
+        if not isinstance(value, dict):
+            error("EXPECTED_RECORD", f"{key} must be a mapping")
+            continue
+        for agent, selector in value.items():
+            if not isinstance(selector, str):
+                error("INVALID_SWITCH", f"{key}[{agent!r}] must use a quoted on/off/model-selector string")
+            elif selector.lower() not in {"on", "off", "true", "false"}:
+                for target in referenced_roles(selector):
+                    if target not in BUILTINS and target not in roles:
+                        error("UNCONFIGURED_ROLE", f"{key}[{agent!r}] references an unconfigured custom role")
+    storage = get_value(config, "modelRoleStorage", "global")
+    if not isinstance(storage, str) or storage not in {"global", "project"}:
+        error("INVALID_ROLE_STORAGE", "modelRoleStorage must be global or project")
+    if known_agents is None:
+        warning("AGENT_DISCOVERY_UNVERIFIED", "No native-discovered agent names supplied; exact-name bindings were not checked")
+    warning("NATIVE_RESOLUTION_UNVERIFIED", "A static pass proves neither native resolution, credential availability, capability support nor correct live worker selection")
+    return {"static_ok": not errors, "native_resolution_tested": False, "builtin_roles_at_pin": sorted(BUILTINS),
+            "configured_role_names": sorted(roles), "errors": errors, "warnings": warnings}
+
+
+def main() -> int:
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument("config", type=Path)
+    p.add_argument("--required-role", action="append", default=[])
+    p.add_argument("--known-agents", type=Path, help="JSON array of exact agent names from actual discovery")
+    args = p.parse_args()
+    try:
+        config = json.loads(args.config.read_text(encoding="utf-8"))
+        names = json.loads(args.known_agents.read_text(encoding="utf-8")) if args.known_agents else None
+        if not isinstance(config, dict):
+            raise ValueError("Expected a JSON object")
+        if names is not None and (not isinstance(names, list) or any(not isinstance(n, str) for n in names)):
+            raise ValueError("known-agents must be a JSON array of strings")
+        report = audit(config, args.required_role, names)
+        print(json.dumps(report, indent=2))
+        return 0 if report["static_ok"] else 1
+    except (OSError, ValueError, TypeError) as exc:
+        print(json.dumps({"status": "error", "error": str(exc)}), file=sys.stderr)
+        return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/skills/omp-native-development/scripts/omp_docs.py

@@ -0,0 +1,252 @@
+#!/usr/bin/env python3
+"""Read, fetch and hash-check a commit-pinned OMP documentation corpus.
+
+Python 3.10+, standard library only. Never runs downloaded code or changes a
+checkout, OMP configuration, credentials, or the bundled reference manifest.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+from pathlib import Path, PurePosixPath
+import re
+import subprocess
+import sys
+import tempfile
+from typing import Any
+from urllib.request import Request, urlopen
+
+REPOSITORY = "can1357/oh-my-pi"
+MAX_BYTES = 2 * 1024 * 1024
+DEFAULT_MANIFEST = Path(__file__).resolve().parents[1] / "references/source-manifest.json"
+
+
+class CorpusError(Exception):
+    pass
+
+
+def git_blob_hash(data: bytes) -> str:
+    return hashlib.sha1(b"blob " + str(len(data)).encode("ascii") + b"\0" + data).hexdigest()
+
+
+def safe_path(root: Path, relative: str) -> Path:
+    p = PurePosixPath(relative)
+    if not relative or p.is_absolute() or ".." in p.parts or "\\" in relative or ":" in relative or "\0" in relative or p.as_posix() != relative:
+        raise CorpusError(f"Unsafe relative path: {relative!r}")
+    root = root.expanduser().absolute()
+    if root.is_symlink():
+        raise CorpusError("Corpus root must not be a symlink")
+    target = root.joinpath(*p.parts)
+    current = root
+    for part in p.parts:
+        current = current / part
+        if current.is_symlink():
+            raise CorpusError(f"Symlink in corpus path: {relative}")
+    return target
+
+
+def load_manifest(path: Path) -> dict[str, Any]:
+    value = json.loads(path.read_text(encoding="utf-8"))
+    if value.get("schema_version") != 1 or value.get("repository") != REPOSITORY:
+        raise CorpusError("Unsupported manifest schema or repository")
+    if not re.fullmatch(r"[a-f0-9]{40}", value.get("commit", "")):
+        raise CorpusError("Manifest commit must be a full lowercase Git SHA")
+    entries = value.get("files")
+    if not isinstance(entries, list) or not entries:
+        raise CorpusError("Manifest contains no files")
+    seen: set[str] = set()
+    for entry in entries:
+        name = entry.get("path", "")
+        part = PurePosixPath(name)
+        if not name or part.is_absolute() or ".." in part.parts or "\\" in name or ":" in name or "\0" in name or part.as_posix() != name:
+            raise CorpusError("Unsafe manifest path")
+        if name in seen or not re.fullmatch(r"[a-f0-9]{40}", entry.get("git_blob_sha1", "")):
+            raise CorpusError(f"Invalid or duplicate manifest entry: {name}")
+        seen.add(name)
+    return value
+
+
+def checked_bytes(entry: dict[str, Any], data: bytes) -> bytes:
+    if len(data) > MAX_BYTES:
+        raise CorpusError(f"File exceeds size limit: {entry['path']}")
+    if git_blob_hash(data) != entry["git_blob_sha1"]:
+        raise CorpusError(f"Git blob hash mismatch: {entry['path']}")
+    data.decode("utf-8")  # Reject binary/non-text responses, even for source files.
+    return data
+
+
+def git(repo: Path, *args: str) -> bytes:
+    result = subprocess.run(
+        ["git", "-C", str(repo.expanduser().absolute()), *args],
+        capture_output=True, timeout=30, check=False,
+        env={**os.environ, "GIT_OPTIONAL_LOCKS": "0", "GIT_TERMINAL_PROMPT": "0"},
+    )
+    if result.returncode:
+        raise CorpusError("Local Git read failed: " + result.stderr.decode("utf-8", "replace")[:400])
+    return result.stdout
+
+
+def fetch_file(manifest: dict[str, Any], entry: dict[str, Any], repo: Path | None) -> bytes:
+    if repo is not None:
+        spec = f"{manifest['commit']}:{entry['path']}"
+        size = int(git(repo, "cat-file", "-s", spec).strip())
+        if size > MAX_BYTES:
+            raise CorpusError("Git object exceeds size limit")
+        return checked_bytes(entry, git(repo, "cat-file", "blob", spec))
+    # Derive the URL, never trust an arbitrary URL in a supplied manifest.
+    url = f"https://raw.githubusercontent.com/{REPOSITORY}/{manifest['commit']}/{entry['path']}"
+    request = Request(url, headers={"User-Agent": "omp-native-development-docs/1.0"})
+    with urlopen(request, timeout=20) as response:
+        data = response.read(MAX_BYTES + 1)
+    return checked_bytes(entry, data)
+
+
+def write_new(target: Path, data: bytes) -> None:
+    """Create atomically without overwriting any existing destination."""
+    target.parent.mkdir(parents=True, exist_ok=True)
+    fd, tmp = tempfile.mkstemp(prefix=".omp-doc-", dir=target.parent)
+    try:
+        with os.fdopen(fd, "wb") as stream:
+            stream.write(data)
+            stream.flush()
+            os.fsync(stream.fileno())
+        os.link(tmp, target)  # Fails, rather than overwrites, when target exists.
+    finally:
+        os.unlink(tmp)
+
+
+def sync(manifest: dict[str, Any], root: Path, repo: Path | None) -> dict[str, Any]:
+    fetched = reused = 0
+    if repo is not None:
+        actual = git(repo, "rev-parse", "--verify", manifest["commit"] + "^{commit}").decode().strip()
+        if actual != manifest["commit"]:
+            raise CorpusError("Local checkout does not contain the pinned commit")
+    for entry in manifest["files"]:
+        target = safe_path(root, entry["path"])
+        if target.exists():
+            checked_bytes(entry, target.read_bytes())
+            reused += 1
+        else:
+            data = fetch_file(manifest, entry, repo)
+            # Recheck before creating parents; this is path hygiene, not OS sandboxing.
+            target = safe_path(root, entry["path"])
+            write_new(target, data)
+            fetched += 1
+    return {"status": "complete", "commit": manifest["commit"], "fetched": fetched, "reused": reused}
+
+
+def verify(manifest: dict[str, Any], root: Path) -> dict[str, Any]:
+    missing: list[str] = []
+    invalid: list[dict[str, str]] = []
+    valid = 0
+    for entry in manifest["files"]:
+        try:
+            target = safe_path(root, entry["path"])
+            if not target.exists():
+                missing.append(entry["path"])
+                continue
+            checked_bytes(entry, target.read_bytes())
+            valid += 1
+        except (CorpusError, OSError, UnicodeError) as exc:
+            invalid.append({"path": entry["path"], "error": str(exc)})
+    return {"complete": not missing and not invalid, "commit": manifest["commit"],
+            "expected": len(manifest["files"]), "valid": valid, "missing": missing, "invalid": invalid}
+
+
+def find_entry(manifest: dict[str, Any], name: str) -> dict[str, Any]:
+    for entry in manifest["files"]:
+        if entry["path"] == name:
+            return entry
+    raise CorpusError("Path is not in the pinned manifest")
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--manifest", type=Path, default=DEFAULT_MANIFEST)
+    sub = parser.add_subparsers(dest="command", required=True)
+    p = sub.add_parser("sync", help="Fetch exact pinned files; existing files must already match")
+    p.add_argument("--out", type=Path, required=True)
+    p.add_argument("--repo", type=Path, help="Read Git objects locally instead of using the network")
+    p = sub.add_parser("verify", help="Verify all expected files; incomplete corpus exits nonzero")
+    p.add_argument("--root", type=Path, required=True)
+    p = sub.add_parser("search", help="Literal, case-insensitive search with source line numbers")
+    p.add_argument("--root", type=Path, required=True)
+    p.add_argument("query")
+    p.add_argument("--limit", type=int, default=30)
+    p.add_argument("--allow-partial", action="store_true")
+    p = sub.add_parser("read", help="Read and hash-check one known file")
+    p.add_argument("--root", type=Path, required=True)
+    p.add_argument("path")
+    p.add_argument("--start", type=int, default=1)
+    p.add_argument("--lines", type=int, default=120)
+    p = sub.add_parser("drift", help="Compare tracked paths at another local Git commit; never updates this skill")
+    p.add_argument("--repo", type=Path, required=True)
+    p.add_argument("--ref", default="HEAD", help="HEAD or an explicit 40-character commit SHA")
+    sub.add_parser("manifest", help="Print corpus scope and pins")
+    args = parser.parse_args(argv)
+    try:
+        manifest = load_manifest(args.manifest)
+        if args.command == "manifest":
+            result: Any = manifest
+        elif args.command == "sync":
+            result = sync(manifest, args.out, args.repo)
+        elif args.command == "verify":
+            result = verify(manifest, args.root)
+            print(json.dumps(result, indent=2))
+            return 0 if result["complete"] else 1
+        elif args.command == "read":
+            if args.start < 1 or not 1 <= args.lines <= 500:
+                raise CorpusError("Use start >= 1 and lines between 1 and 500")
+            entry = find_entry(manifest, args.path)
+            text = checked_bytes(entry, safe_path(args.root, args.path).read_bytes()).decode()
+            print(entry["url"] + f"#L{args.start}")
+            for number, line in enumerate(text.splitlines(), 1):
+                if args.start <= number < args.start + args.lines:
+                    print(f"{number}: {line}")
+            return 0
+        elif args.command == "search":
+            if not args.query.strip() or not 1 <= args.limit <= 100:
+                raise CorpusError("Use a nonempty query and a limit between 1 and 100")
+            report = verify(manifest, args.root)
+            if report["invalid"] or (not report["complete"] and not args.allow_partial):
+                raise CorpusError("Corpus is invalid or incomplete; sync it first (or explicitly allow missing files)")
+            matches = []
+            for entry in manifest["files"]:
+                path = safe_path(args.root, entry["path"])
+                if not path.exists():
+                    continue
+                for number, line in enumerate(checked_bytes(entry, path.read_bytes()).decode().splitlines(), 1):
+                    if args.query.casefold() in line.casefold():
+                        matches.append({"path": entry["path"], "line": number, "text": line[:1000],
+                                        "source": entry["url"] + f"#L{number}"})
+                        if len(matches) >= args.limit:
+                            break
+                if len(matches) >= args.limit:
+                    break
+            result = {"corpus_complete": report["complete"], "matches": matches, "limit": args.limit}
+        else:
+            if args.ref != "HEAD" and not re.fullmatch(r"[a-f0-9]{40}", args.ref):
+                raise CorpusError("Drift ref must be HEAD or a full lowercase commit SHA")
+            commit = git(args.repo, "rev-parse", "--verify", args.ref + "^{commit}").decode().strip()
+            differences = []
+            for entry in manifest["files"]:
+                try:
+                    actual = git(args.repo, "rev-parse", "--verify", f"{commit}:{entry['path']}").decode().strip()
+                except CorpusError:
+                    actual = None
+                if actual != entry["git_blob_sha1"]:
+                    differences.append({"path": entry["path"], "expected": entry["git_blob_sha1"], "actual": actual})
+            result = {"baseline": manifest["commit"], "compared_commit": commit,
+                      "same_commit": commit == manifest["commit"], "changed_or_missing": differences,
+                      "warning": "Tracked-path comparison only; inspect newly added APIs/docs separately."}
+        print(json.dumps(result, indent=2))
+        return 0
+    except (CorpusError, OSError, ValueError, UnicodeError, subprocess.SubprocessError) as exc:
+        print(json.dumps({"status": "error", "error": str(exc)}), file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())