jc (JSON Convert) is a mature Python library and CLI tool that converts the output of over 150 command-line tools, system files, and common data formats into structured JSON. It operates both as a piped command-line utility (`jc <command>`) and as a programmable Python module (`jc.parse('parser_name', data)`), enabling seamless integration with jq, scripting, and automation pipelines. The architecture follows a consistent parser pattern: each parser module defines an `info` metadata class and a `parse(data, raw, quiet)` function, with optional `_process()` for type coercion. Streaming parsers (suffixed `_s`) use generator-based patterns for real-time output. The library includes vendored dependencies for ASN.1, plist, EDID, and TOML parsing, and supports cross-platform execution across Linux, macOS, FreeBSD, and Windows. The primary data flow is stdin or file input → parser module → structured dict/list output (JSON or YAML). Key entry points include the CLI (`jc/cli.py`), the library API (`jc/lib.py`), and individual parser modules under `jc/parsers/`. The project maintains an extensive test suite with fixtures captured from multiple OS versions, ensuring robustness against command output variations. It also provides shell completions, a plugin system for custom parsers, and documentation generation scripts. While the codebase is well-engineered with clean abstractions, the sheer number of parsers and reliance on vendored libraries introduce moderate maintenance surface area.
Amber is a Rust-based compiler that transpiles a high-level, statically-typed programming language into shell scripts (Bash, Zsh, Ksh). It provides a modern language with features like functions, type inference, generics, optional arguments, failable types, imports, loops, range expressions, array operations, and a standard library for file system, text, HTTP, math, and environment operations. The compiler architecture is modular: a CLI entry point (src/main.rs) dispatches to subcommands (build, run, eval, check, docs, test). The compilation pipeline (src/compiler.rs) orchestrates tokenization via heraclitus-compiler, parsing into a typed AST, type checking with control-flow analysis, translation to an intermediate fragment AST, optimization passes (unused variable removal, ephemeral variable elimination), and final shell code generation with post-processing (e.g., shell syntax checking). The system supports multiple shell targets and generates version-specific code. The codebase is well-structured with procedural macros (meta crate) for keyword registration and context management, and a comprehensive test suite using snapshot testing (insta). While alpha quality, the engineering is serious and the architecture shows thoughtful design patterns.
Autoresearch-opencode is an OpenCode plugin and skill that enables autonomous code optimization experiments. It provides a slash command (`/autoresearch`) and a TypeScript plugin that injects context into the AI agent's system prompt to guide it through an iterative experiment loop. The system defines a protocol for the agent: it reads/writes a JSONL state file (`autoresearch.jsonl`), generates experiment scripts (`autoresearch.sh`), and maintains a worklog (`experiments/worklog.md`). The core logic is documented in markdown files (SKILL.md, commands/autoresearch.md) rather than executable code, making it a hybrid of documentation and configuration. The repository includes a well-crafted bash backup utility (`scripts/backup-state.sh`) and example optimization targets (bogo_sort.py). The system is designed to be used within the OpenCode environment and does not function as a standalone application.