This is an OpenCode plugin that provides isolated branch workspaces using devcontainers or git worktrees. It enables developers to work on multiple branches simultaneously with full container isolation (devcontainers) or lightweight filesystem isolation (worktrees). The plugin manages the entire lifecycle: creating clones or worktrees, allocating unique ports from a configurable range, copying gitignored secrets, and intercepting bash commands to run inside the target container or worktree directory. It also offers session state persistence, background job tracking for non-blocking container starts, and unified workspace management with cleanup of stale workspaces. The codebase is well-architected with clean separation into core modules (clones, config, devcontainer, git, jobs, paths, ports, worktree, workspaces) and a main plugin entry point that registers tools and bash interception hooks. It uses Node.js built-in test runner with comprehensive unit and integration tests. The plugin demonstrates strong engineering practices including file-based locking for concurrency, atomic writes, security-conscious command construction (shell quoting, Docker filter sanitization), and support for both Docker and Podman runtimes.
This repository implements a GitHub Action that automates deployment of static content to GitHub Pages. It takes a folder from the workspace, optionally builds it, and pushes the contents to a specified branch (default `gh-pages`) using git worktrees and rsync. The action supports authentication via GitHub token, personal access token, or SSH deploy keys, and offers extensive configuration options including clean deployments, single-commit history, target subfolders, dry runs, tags, and Git LFS. The architecture is modular: `src/main.ts` is the entry point, `src/lib.ts` orchestrates the workflow, `src/git.ts` handles repository initialization and deployment, `src/worktree.ts` manages git worktree creation with retry logic, `src/ssh.ts` configures SSH clients, and `src/execute.ts` provides a reusable command execution wrapper. The action relies on external tools `git`, `rsync`, and `ssh-agent`, and uses the `@actions/*` toolkit for GitHub Actions integration. The codebase is well-structured TypeScript with comprehensive unit and integration tests, and follows modern JavaScript practices with ESLint, Prettier, and Jest.
Liza is a disciplined multi-agent orchestration system for AI-assisted software development. It manages a pipeline of roles (orchestrator, coder, reviewer, architect) that collaborate via a behavioral contract enforced by deterministic Go code. The system provides a CLI (Cobra) and a Bubbletea TUI, with a YAML-based state file (blackboard) for persistence, Git worktree isolation per task, and a state-machine task lifecycle (planning → implementation → review → merge). It integrates with multiple LLM providers (Claude, Codex, Gemini, etc.) via their CLIs or the Agent Context Protocol (ACP). The architecture follows a clean layered design: `cmd/liza/` contains CLI commands, `internal/commands/` are thin adapters, `internal/ops/` holds core business logic (claiming, submitting, reviewing, merging, recovering), `internal/models/` defines domain types, and `internal/db/` manages the blackboard. The system is heavily test-covered with unit, integration, and lifecycle replay tests. It also includes optional codebase indexing via SCIP, Stacklit, and Semble for improved context. Key features include generation-fenced agent authority, circuit breaker anomaly detection, sprint metrics, checkpoint summaries, automated dependency repair, and pre-commit hooks. The repository is well-documented with extensive ADRs, architecture diagrams, and skill definitions. While the codebase is large and has some platform-specific code (Windows support), it demonstrates high craftsmanship in its use of idempotent lifecycle receipts, file-locking primitives, and error classification.
This is a Claude Code plugin that enables scheduling recurring and one-time tasks using native OS schedulers (launchd on macOS, crontab on Linux, Task Scheduler on Windows). Users describe tasks in natural language (e.g., 'every weekday at 9am review yesterday's code'), and the plugin converts that to cron expressions, registers the task with the OS scheduler, and executes `claude -p "prompt"` at the scheduled time. It supports autonomous execution with `--dangerously-skip-permissions`, git worktree isolation for tasks that modify code (creates a branch, runs Claude, commits and pushes changes), and provides commands to list, remove, run, and view logs of scheduled tasks. The architecture is modular: platform-specific scheduler implementations inherit from a base class, cron parsing and humanization are separate utilities, and execution history is stored as JSONL files. The codebase demonstrates strong security awareness with shell escaping, input validation via Zod schemas, and careful handling of user-provided values in generated shell scripts.
callx is a Node.js CLI tool that serves as a unified runtime switcher and configuration manager for AI coding assistants like Claude Code and OpenCode. It allows users to define multiple AI 'sprites' (agent configurations) with different providers, models, skills, and MCP servers, all managed through a single `~/.config/callx` directory. The system provides two entry points: the `call` command for quick invocation of sprites, and `callcli`, a full-featured TUI built with Ink and React for managing providers, sprites, skills, MCP servers, and git worktrees. The architecture is a monolith CLI application with a clear separation between runtime utilities (`lib/runtime.js`), git worktree helpers (`lib/worktree.js`), and the TUI frontend (`lib/callcli/app.mjs`). The runtime module handles all configuration file I/O, provider normalization, skill syncing via symlinks, and MCP server configuration generation for both Claude Code and OpenCode formats. The TUI provides a Monokai-themed interface with list-based navigation, field-level editing, and multi-select for skills and MCP servers. Key data flows include: reading `providers.json` for API keys and endpoints, reading sprite `config.json` for CLI type and model selection, syncing skill packs from `skillpacks/` to sprite-specific `skills/` directories via symlinks, and generating MCP configuration files from `mcpservers/` definitions. The tool also integrates with git worktrees, providing an interactive flow to create new branches and worktrees with suggested naming conventions. External dependencies are minimal: Node.js 18+, Ink and React for the TUI, and the target AI CLI tools (opencode-ai, @anthropic-ai/claude-code).
Noodle is an open-source AI agent orchestration framework written in Go that manages autonomous coding agents through a kitchen-brigade model. It operates as a background daemon with a CLI (`noodle start`, `noodle status`, `noodle worktree`) and a real-time React/TypeScript web UI. The core loop reads backlog items (from markdown files via shell-script adapters), schedules multi-stage orders, dispatches agents (Claude Code, Codex) into isolated git worktrees, monitors their progress via NDJSON event logs, handles merge conflicts, and supports human-in-the-loop review gates. The system is config-driven via `.noodle.toml` and uses skills (directories with `SKILL.md` frontmatter) as the sole extension point for defining agent behavior and task types. Architecturally, Noodle is a monolith with clear internal packages: a state-machine loop (`loop/`), dispatchers for process and remote runtimes (`dispatcher/`), a parser pipeline for provider NDJSON output (`parse/`, `stamp/`), session monitoring (`monitor/`), event-sourced state management (`internal/reducer/`, `internal/state/`), a projection layer for incremental UI updates (`internal/projection/`), and a WebSocket server (`server/`). The UI is built with TanStack Router, React Query, and D3 for agent tree visualization. State is persisted as JSON/NDJSON files under `.noodle/`, with crash recovery via atomic snapshots and idempotent event ingestion. Key design patterns include: event sourcing with a deterministic reducer and effect ledger, directory-based fixture testing with source hash validation, a failure taxonomy with recoverability classification, mode gating for autonomy levels (auto/supervised/manual), and a plugin system via JSON-RPC for external runtimes. The codebase demonstrates strong engineering discipline with extensive test coverage (unit, integration, e2e with Playwright), CI/CD via GitHub Actions and GoReleaser, and a comprehensive brain vault for agent knowledge persistence.