Skip to content
xsovad06Public

About

Autonomous AI-assisted development: takes GitHub Issues, develops via TDD, self-reviews, creates PRs, monitors CI, addresses feedback. CLI + web dashboard + scheduler.

Topics

Resources

Code of conduct

Contributing

Security policy

Stars

3 stars

Watchers

0 watching

Forks

Latest commit

 

History

1,673 Commits

Folders and files

NameName
Last commit message
Last commit date
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

SOVA: Software Orchestration Via Agents

SOVA Logo

CI License Python

What is SOVA?

SOVA is a standalone application that turns GitHub Issues into merged pull requests, autonomously. Install it into any software project and it will triage issues, research the codebase, develop solutions using TDD, self-review, create PRs, monitor CI, and address review feedback. You stay in control through a web dashboard and a human-in-the-loop handoff system, while SOVA handles the repetitive engineering work.

Why SOVA?

  • End-to-end automation: from issue triage to merged PR, SOVA handles the full development cycle. You approve, it executes.
  • Quality by design: gate checks between every pipeline step catch problems early. Agents refuse to work on issues that haven't been properly triaged and researched.
  • Learns from mistakes: lessons are kept as markdown in .claude/agent-memory/, captured through the human-reviewed /extract-knowledge command, and sova retro measures how often review findings repeat a recorded rule.
  • You stay in control: agents are ephemeral (spawn, work, handoff, exit). The dashboard shows what they did, what they need, and lets you decide when to merge. Nothing ships without your approval.
  • Works on any project: install once, configure with sova config set or the dashboard, and SOVA detects your stack from marker files (Django, FastAPI, Odoo, and more).

Key Features

  • Role-Based Agents: specialized triage, researcher, developer, and reviewer roles with automatic dispatch and autonomous Developer-Reviewer chaining
  • Gate-Checked Pipeline: every step validates its output before the next begins; Developer pipeline (17 steps), Address-Review pipeline (10 steps)
  • Web Dashboard: 24-page UI for monitoring runs, costs, agent control, lifecycle tracking, and configuration
  • 24/7 Server Mode: scheduler with a priority-based watch loop; sova parallel runs several issues concurrently
  • Handoff System: per-issue handoff files eliminate race conditions in parallel agent runs; dashboard renders action buttons for human decisions
  • 28 Standardized Commands: develop, test, review, PR, ship, debug, and more. Works on any project
  • Markdown Knowledge System: project rules plus agent memory captured via /extract-knowledge, and a review retro (sova retro) that tracks repeated findings (details)
  • Stack Detection: detects your tech stack from marker files and shows it on the Settings page
  • Pluggable Task Sources: GitHub Issues and Jira Cloud supported, Linear planned

Architecture Overview

graph LR
    A[Issue Tracker] --> B[Triage]
    B --> C[Research]
    C --> D[Develop]
    D --> E[Self-Review]
    E --> F[Create PR]
    F --> G[Monitor CI]
    G --> H[Code Review]
    H --> I[Merge]

    style A fill:#313244,stroke:#cdd6f4,color:#cdd6f4
    style B fill:#313244,stroke:#89b4fa,color:#89b4fa
    style C fill:#313244,stroke:#89b4fa,color:#89b4fa
    style D fill:#313244,stroke:#a6e3a1,color:#a6e3a1
    style E fill:#313244,stroke:#a6e3a1,color:#a6e3a1
    style F fill:#313244,stroke:#f9e2af,color:#f9e2af
    style G fill:#313244,stroke:#f9e2af,color:#f9e2af
    style H fill:#313244,stroke:#cba6f7,color:#cba6f7
    style I fill:#313244,stroke:#a6e3a1,color:#a6e3a1
Loading

Each transition is enforced by gate checks. The Developer refuses issues that haven't been triaged and researched first (use --force to bypass for quick fixes).

Requirements

  • Python 3.12+
  • Claude Code CLI (claude)
  • GitHub CLI (gh): authenticated
  • git with configured identity: git config user.name and git config user.email
  • terminal-notifier (macOS, optional): brew install terminal-notifier for rich desktop notifications with custom icon and sound

Installation

git clone https://github.com/xsovad06/sova.git
cd sova
pip install --user -e .

Ensure your Python user bin directory is on PATH:

# macOS (replace 3.12 with your Python version)
export PATH="$HOME/Library/Python/3.12/bin:$PATH"

# Linux
export PATH="$HOME/.local/bin:$PATH"

For Vertex AI support (Google Cloud ADC for LLM suggestions and batch processing):

pip install --user -e ".[vertex]"

For development (tests, linting):

pip install --user -e ".[dev]"

Quick Start

# Install SOVA into your project (creates database config, deploys commands)
sova install /path/to/project

# Optional: run the interactive setup wizard for custom configuration
sova setup /path/to/project

# Triage an issue to assess agent suitability
sova triage 42

# Work on an issue (runs the full pipeline: develop, test, review, PR)
sova run 42

# Or start the server for fully autonomous operation
sova server start

Dashboard

The web dashboard is SOVA's primary interface for monitoring and controlling agents.

sova dashboard --project /path/to/project    # http://localhost:8111
Page Purpose
Home Project list (command center) for multi-project installations
Work What runs, what needs you and what to start next: a header (agents and their limit, queue, spend, CodeRabbit, supervisor switch), a board (Up next, Queued, Running, In review, Needs you, Done today) with an issue drawer and Mine/All owner filter, the dependency chains, open PRs and run history. /agents redirects here
Run Detail Per-run step pipeline, logs, and cost breakdown
Lifecycle Issue lifecycle rail (development through post-merge)
Costs Per-task and per-model cost tracking and aggregation
Queue Batch triage/harden operations with progress tracking
Roles View and edit custom workflow roles (DAG-based)
Settings Runtime configuration management
Setup Project onboarding wizard with directory browser
Style Guide Design system reference with live component examples

On the Work board, Up next ranks issues ready for an agent. Queued is the saved order the supervisor starts when it is on and a slot is free. Running includes active runs, rebases, and issues marked in progress. In review contains open PRs still in draft, CI, review, or changes requested, plus issues marked in review by the tracker; it does not imply unresolved review findings. The PR's thread count shows resolved/total, so the difference is unresolved. Needs you contains merge decisions, approvals, and failed runs. Mine matches an issue assignee to the configured identity for that issue's tracker, or a PR author or assignee to the GitHub user. The header totals remain project wide.

Remote Access over Tailscale

The dashboard stays bound to loopback. To reach it from your own phone or laptop, publish it to your tailnet with Tailscale Serve (never Funnel, which would make it public) and tell SOVA which origin and which Tailscale login to accept:

tailscale serve --bg --https=443 http://127.0.0.1:8111
sova config set dashboard.proxy_origins https://<machine>.<tailnet>.ts.net
sova config set dashboard.proxy_allowed_logins you@example.com   # your Tailscale login
sova server restart                                              # both settings apply at startup

Both settings apply to the whole server and are read once at startup, from the project the server serves. On the multi-project hub (sova server start --multi) that is the directory the server was started in, so run the sova config set lines there, or set SOVA_DASHBOARD_PROXY_ORIGINS and SOVA_DASHBOARD_PROXY_ALLOWED_LOGINS (JSON arrays) in the server environment; a value saved in any other project has no effect.

Enable HTTPS certificates in the Tailscale admin console first, and consider restricting the access policy to your own devices (autogroup:self). A request through the proxy origin without an allowed login, and any Funnel request, gets 403. If the first HTTPS request fails with a TLS error, tailscale cert <machine>.<tailnet>.ts.net prints the underlying certificate error. The security model is in docs/security-guidelines.md, "Dashboard Security Model".

On a phone, open /phone (/p/<slug>/phone on the hub) instead of the Work page: one narrow column with what waits on you (handoffs and the supervisor's pending plan), the running agents with Stop, and a field to start an issue. It uses the same endpoints as the Work page, so it needs no extra setup.

Configuration

Note: SOVA uses database-backed configuration (.claude/sova.db). Edit it with sova config set <key> <value>, the dashboard Settings page, or SOVA_* environment variables. Read a single value (for scripts or commands) with sova config get <key>; lists and dicts print as JSON, and a secret key always prints (secret). A legacy sova.toml is still read once and auto-migrated into the database if one is present. See Configuration Troubleshooting for details.

The settings are shown below in TOML form for reference (this is a rendering of the stored keys, not a file SOVA writes). Minimal example (required fields only):

github_repo = "owner/repo"
github_user = "owner"

[task_source]
type = "github"

Key optional sections:

[agent]
model = "opus"              # LLM model for agent steps
max_budget = 10.0           # Max USD per run ($10 default)

[ci]
max_fix_attempts = 2        # Auto-fix CI failures (0 to disable)
max_wait = 900              # Seconds to wait for CI checks

[pipeline]
auto_handoff = true         # Developer auto-hands off to Reviewer
auto_address_review = true  # Reviewer auto-triggers address-review

[telemetry]
hub_url = "https://your-hub.example.com"  # Push run summaries to a central hub (SOVA_TELEMETRY_HUB_URL)
hub_token = ""                             # Bearer token (SOVA_TELEMETRY_HUB_TOKEN)
machine_id = ""                            # Auto-derived from hostname+username when empty (SOVA_TELEMETRY_MACHINE_ID)

[mcp.atlassian]
enabled = false             # Opt-in Confluence + Jira sidecar (mcp-atlassian, needs uvx)
jira_url = "https://issues.example.com"
confluence_url = "https://docs.example.com"
auth_type = "pat"           # "pat" for on-prem, "api_token" for Cloud (paired with email)
read_only = true            # Agents read context; writes still go through the task adapter

sova install writes enabled MCP sidecars to <project>/.mcp.json and approves them in .claude/settings.json. Leave token empty and export SOVA_MCP_ATLASSIAN_TOKEN to keep the credential out of that file. See Integration Guidelines for details.

SOVA generates commit subjects and PR titles as conventional-commit lines, validated against commit.types and commit.scopes. When unset, each list is read from a Valid types:/Valid scopes: line in your AGENTS.md or CLAUDE.md, else derived from your recent git history (SOVA's own lists apply only to the SOVA repository); sova install and sova commands update store the result, and sova doctor warns when commit.scopes still matches SOVA's defaults. See Commit Convention Setup.

For the full configuration reference, see sova/config/models.py. Environment variables override TOML values using the SOVA_ prefix (e.g., SOVA_BASE_BRANCH=develop).

Claude Code Setup

SOVA uses the Claude Code CLI as its default LLM provider. For production deployments with cost tracking and quota management, configure Claude Code to use Google Vertex AI:

1. Install Vertex AI Dependencies

pip install --user -e ".[vertex]"

This installs google-auth and related packages needed for Google Cloud authentication.

2. Authenticate with Google Cloud

gcloud auth application-default login

This sets up Application Default Credentials (ADC) that Claude Code and SOVA will use to authenticate with Vertex AI.

3. Configure Claude Code for Vertex AI

Run the Claude Code login wizard:

claude

Then run /login and select:

  • Login method: 3rd-party platform
  • Provider: Google Vertex AI
  • Authentication method: Application Default Credentials (gcloud auth)
  • Project: Your GCP project ID (e.g., my-gcp-project-123)
  • Region: global (recommended for latest models)
  • Models: Pin the working models (Sonnet, Opus, Haiku)

4. Set Environment Variables

Add to your shell configuration (~/.zshrc or ~/.bashrc):

export ANTHROPIC_VERTEX_PROJECT_ID="your-gcp-project-id"
export CLOUD_ML_REGION="global"

After updating, reload your shell:

source ~/.zshrc  # or source ~/.bashrc

5. Verify Configuration

Test that Claude Code can access Vertex AI:

claude -p "Say hello" --model sonnet

If configured correctly, you should see a response from Claude via Vertex AI.

Notes

  • The global region provides access to the latest Claude models and uses the base Vertex AI endpoint (aiplatform.googleapis.com).
  • Regional endpoints (e.g., us-east5) use region-prefixed domains ({region}-aiplatform.googleapis.com).
  • SOVA's LLM suggestion feature and batch processing both use these same credentials when ANTHROPIC_VERTEX_PROJECT_ID is set.

Alternative Agent Runtimes

agent.runtime selects which coding-agent CLI SOVA spawns to execute a pipeline step. The accepted values are "claude-code" (the default), "codex", and "aider". Setting it to "codex" runs OpenAI's Codex CLI; see Codex Runtime Setup Guide for authentication (browser login with keyring storage, the device-auth and stdin API-key fallbacks, and the trusted-automation-only CODEX_API_KEY pattern), sandbox configuration, and rollback.

Notifications

SOVA supports multiple notification backends for agent handoffs and system events:

[notification]
# Desktop notifications (macOS via terminal-notifier or JXA, Linux via notify-send)
desktop = false

# Slack webhook
slack_webhook_url = ""

# Email via SMTP
email_enabled = true
email_to = "dev@example.com"
email_from = "sova@example.com"
email_smtp_host = "smtp.example.com"
email_smtp_port = 587
email_smtp_starttls = true
# Credentials via env: SOVA_NOTIFICATION_EMAIL_SMTP_USER, SOVA_NOTIFICATION_EMAIL_SMTP_PASSWORD

# Generic webhook (HTTP POST)
webhook_url = "https://hooks.example.com/sova"
webhook_headers = '{"Authorization": "Bearer token123"}'  # JSON object with custom headers
# The webhook payload also carries kind, issue (a string, or null), pr_number, run_id and url (null without link_base_url)

# Self-hosted ntfy server (skipped when ntfy_url or ntfy_topic is empty)
ntfy_url = "https://ntfy.example.com"
ntfy_topic = "sova"
ntfy_events = ["needs_human", "failed"]   # kinds sent to ntfy: needs_human, failed, finished, info
link_base_url = "https://sova.example.com"  # notification link: /work/<id>, else /work
# Bearer token: sova config set notification.ntfy_token <token> (stored in the OS keyring when available);
# the SOVA_NOTIFICATION_NTFY_TOKEN environment variable overrides the stored token
# SOVA_NOTIFICATION_NTFY_EVENTS takes comma-separated text or a JSON array

Every notification has a kind (needs_human, failed, finished or info). Only ntfy filters by kind (ntfy_events); the other backends receive every event. Entries in ntfy_events are trimmed and lowercased, and an unknown or malformed entry is ignored with a warning rather than failing config load. A run that is waiting on you sends one needs_human push; the exit-time summary for it (and for a step failure the engine already reported, or a finish the engine already reported) is info, so the default filter yields exactly one push and opting into finished does not double it.

Point ntfy at a self-hosted server. Topics on the hosted ntfy.sh are public (anyone who guesses the topic name can read it) and are not end-to-end encrypted, so issue titles, step errors and dashboard links would leave your network.

All backends are fire-and-forget. Errors are logged but never block agent execution.

Server Management

SOVA can run as an always-on service (dashboard + scheduler daemon):

# Start the server
sova server start --host 127.0.0.1 --port 8111

# Restart the server
sova server restart

# Stop the server
sova server stop

# Check server status
sova server status

# View activity summary
sova server digest --hours 24

# Install as system service (systemd on Linux, launchd on macOS)
sova server install-service --type systemd --project /path/to/project

After installing as a service:

# systemd
systemctl --user enable sova-server
systemctl --user start sova-server
systemctl --user status sova-server

# launchd
launchctl load ~/Library/LaunchAgents/com.sova.server.plist
launchctl start com.sova.server
launchctl list | grep sova

The systemd unit is a user unit (systemctl --user) and lists the resolved project directory in ReadWritePaths, since agents write {project}/.git as well as {project}/.claude; ~/.claude.json and ~/.codex are listed with a leading - (the CLIs' own state, optional on a host without one). A project path containing whitespace is refused: systemd splits those directives on whitespace, so adapt deploy/sova-server.service by hand instead. The unit is Type=notify with WatchdogSec=60: the server sends READY=1 once startup recovery has finished and uvicorn has bound the port, then pings the watchdog every 15s on a fixed schedule while the event loop answers (stdlib sd_notify, a no-op off systemd), so a wedged server is restarted by systemd (WatchdogSignal=SIGTERM, no core dump). The ping is deliberately not gated on /api/health staying 200 or on the database probe: a tracker outage, an expired token or an unreachable database turns that degraded (HTTP 503), and a restart cannot fix any of them.

Restarts keep agents running. Agents run in their own session with output redirected to .claude/agent-output/<run_id>.stdout, and the unit sets KillMode=process, so systemctl --user restart sova-server stops only the server. On startup the new server adopts each live agent it launched (PID alive and process creation time matching the run's started_at) and keeps managing it; output capture resumes from the end of the agent's .stdout file, so what the agent wrote while no server was running stays in that file rather than in the dashboard log. Adoption is a claim held with a lock file (.claude/agent-output/<run_id>.adopt.lock), so two servers on one project database cannot both manage, finalize and hand off the same run. It only reads the agent's worktree and never repairs or recreates it. A dead PID is recorded from what the run left behind (a PR handoff, or for a command run the final result line in its .stdout: done or failed, else interrupted); a live PID that is not the run's process (PID reuse) is marked interrupted. Neither is ever signalled. An adopted agent's exit code is not available, so it is derived from the run's status, its handoff or the final result line in its .stdout; when none of them says how it ended, the run is recorded interrupted rather than failed. The previous server's pre-run baseline is gone, so an adopted address-pr, rearrange-commits or integrate-pr run is not diff-guarded (no silent-revert or pin-downgrade check; adopt.diff_guard_baseline_unavailable is logged). An address-pr command without its pre-run PR head baseline is recorded as interrupted rather than being accepted from a synchronized branch or output text. Set recovery.kill_orphans = true to kill identity-matched orphans at startup instead. Agents are left running only when a service manager runs the server (systemd, or the launchd plist): because of KillMode=process, systemctl --user stop also leaves agents running until the next start adopts them, so stop them from the dashboard first, or kill them by hand. An interactive sova server start or sova dashboard (Ctrl+C) still stops its agents on shutdown.

Unverified on Linux: the Claude CLI rewrites ~/.claude.json by writing a temp file and renaming it over the original. A single-file read-write bind mount may not allow that rename, and sibling files at the home root (backups, locks) stay read-only under ProtectHome=read-only. If agents cannot save state under the unit, relax ProtectHome for it.

On macOS, install-service --type launchd also writes ~/.config/sova/sova-server.newsyslog.conf and prints a sudo cp command for it: launchd never rotates its own StandardOutPath/StandardErrorPath, and newsyslog is what does. It holds those descriptors open for the life of the process, so each entry sends SIGHUP to the server's PID after rotation. The server reopens the files named by SOVA_SERVER_LOG and SOVA_SERVER_ERR_LOG (set in the generated plist) in place: no restart, so running agents are undisturbed. The server takes over SIGHUP only when one of those variables is set (a service manager owns the log files); an interactive sova server start keeps the default, so closing its terminal still stops it. When stdout is a terminal, the reopen is skipped with a log line. SIGHUP is ignored while the server is starting or stopping, so a rotation in that window is skipped, never fatal. SOVA's own .claude/sova.log is rotated in-process and needs none of this.

Health monitoring: The server exposes health and digest endpoints for external monitoring:

  • GET /api/health: status (ok or degraded), database (ok or unreachable, a probe bounded to 2s), uptime, scheduler state, active agent count, package version and git SHA. Answers HTTP 503 (same JSON body) when degraded: the watch loop's last completed scan is older than three times watch.interval_idle while no task is in flight, or the database probe failed. code_sha (full HEAD when the server started), checkout_sha (full HEAD now, read from .git and cached for 5s) and restart_required (both known and different) report a server running older code than its checkout; informational only, it never changes status or the HTTP code, and every dashboard page shows a restart banner while it is true. An ImportError escaping any route answers 503 with a detail telling the operator to restart.
  • GET /api/scheduler/health: uptime, scan count, error count, agent slots, DB status
  • GET /api/scheduler/digest?hours=24: tasks completed/failed, cost summary

Log rotation: The server and every sova run write .claude/sova.log, each through its own rotating handler built from the same two settings (10 MB max, 5 backups by default), so they agree on when to roll it. The server reads them at startup, so a change takes effect on the next restart. Configure via:

[server]
log_max_bytes = 10485760    # 10 MB
log_backup_count = 5

CLI Reference

Category Commands
Core sova run <issue>, sova triage <issue>, sova harden <issue>, sova watch, sova parallel
Server sova server start|stop|restart|status|digest|install-service
Setup sova install <path>, sova setup <path>, sova uninstall <path>, sova init-db, sova doctor
PR Ops sova address-pr <pr>, sova maintain-pr <pr>, sova review-pr <pr>, `sova linked-issues [--apply
Monitor sova status, sova costs, sova briefing (setup), sova config, sova dashboard
Knowledge sova assess set|get|clear <issue>
Commands sova commands list|diff|update|sync
Review retro sova retro record <pr> [--force], sova retro backfill [--dry-run], sova retro report [--since YYYY-MM], sova retro top-rules [--limit N] [--since YYYY-MM] (the most repeated rules as JSON, read by /review and /review-pr): which recorded rules (bold-labelled bullets in AGENTS.md, CLAUDE.md, .claude/rules/, common-mistakes.md) each merged PR's review findings repeat, per month
MCP sova mcp serve (blocking command tools, plus operator tools that drive a running sova server: status, pending handoffs and plan, start, stop, resume, handoff dismiss and action, plan approve and skip)
Maintenance sova cleanup

Run sova --help for the full list.

Registering the MCP Server in Claude Code

Bind the server to one project so every tool acts on it, then allow the two read-only operator tools and leave the rest on ask, so each start, stop or approval shows Claude Code's permission prompt:

claude mcp add sova -- sova mcp serve --project /path/to/project

Put this in .claude/settings.json (project) or ~/.claude/settings.json (user), merged into any existing permissions.allow list:

{
  "permissions": {
    "allow": ["mcp__sova__sova_status", "mcp__sova__sova_pending"]
  }
}

The operator tools call the running sova server (or sova dashboard) over loopback at the configured server.host and server.port, then dashboard.port, so they go through the same duplicate, budget and suitability checks as the dashboard. A server started with --port on a port the config does not name is not found. Each call first asks the endpoint which project it serves, so a sova server started before this version existed (no identity route) must be restarted on the same SOVA version before the operator tools will act on it; an endpoint that is not a SOVA dashboard, or serves another project, is skipped in favor of the next configured port. That permission prompt is the human confirmation: tracker text the session reads (issue titles, handoff summaries) can carry instructions, and the tools never accept a force or budget override.

How It Works

SOVA uses a role-based architecture with four specialized agent types:

  1. Triage: assesses issues for agent suitability, applies labels (agent:ready, agent:needs-spec, agent:needs-research, agent:interactive-recommended, agent:human-only). triage.interactive_title_prefixes and triage.interactive_labels are empty by default; set triage.interactive_title_prefixes = ["[Spike]"] to classify such titles as interactive. agent:interactive-recommended blocks autonomous scheduling until a human starts the run.
  2. Researcher: investigates the codebase and writes an implementation spec
  3. Developer: implements the solution using TDD, creates a PR, monitors CI
  4. Reviewer: reviews the PR, posts findings, triggers a fix cycle if needed

Agents are ephemeral: each one spawns, does its job, writes a handoff file, and exits. The orchestrator (scheduler or dashboard) reads the handoff and spawns the next agent in the chain. Developer and Reviewer chain autonomously: when the Developer finishes, it hands off to the Reviewer, which hands back to the Developer if findings exist. This loop continues until the code is clean, then SOVA notifies you and waits for your merge decision.

Task Sources

Source Status
GitHub Issues Supported
Jira Cloud Supported (configuration guide)
Linear Planned

Marketplace

A subset of SOVA's distributable commands (develop, spec, review, pr, debug, test) is packaged as a standalone Claude Code plugin in plugins/sova/, adapted to run in any project without installing SOVA itself. This plugin is intended for publication to the Claude AI Helpers Marketplace; until that PR is submitted and merged, install it directly from this repository:

/plugin marketplace add xsovad06/sova
/plugin install sova@sova

Awareness Briefing

SOVA's awareness subsystem aggregates information from Gmail, Google Calendar, GitHub PRs, Apple Reminders, and agent runs into a unified morning briefing. Run sova briefing to see everything that needs your attention in one place.

What it surfaces:

  • Unread emails and threads needing replies
  • Today's calendar schedule and upcoming meetings
  • Open PRs (yours and awaiting your review)
  • Failed or interrupted agent runs
  • Apple Reminders tasks (macOS only)

Setup: See Awareness Setup Guide for Google OAuth2 configuration and provider details.

Contributing

Contributions are welcome. See CONTRIBUTING.md for setup, code style, and PR guidelines.

SOVA has no bounty, reward, or paid-contribution program. There is no /claim, /bounty, or /reward command, and no bounty platform is connected to this repository. Pull requests carrying bounty claim syntax are closed automatically (see No Bounty Program).

make check    # Lint + test (close to CI; see docs/testing-guidelines.md for what it does not cover)
make lint     # ShellCheck + Ruff + dashboard JS syntax check (needs node; see CONTRIBUTING.md) + import layering contract + whole-tree invariant scans
make test     # All tests (bash + python)
make format   # Auto-format Python

Getting Help

  • Run sova doctor to check your environment setup
  • Run sova --help or sova <command> --help for CLI usage
  • Config issues? See Troubleshooting Configuration for common errors and fixes
  • File an issue for bugs or questions
  • See CONTRIBUTING.md for development setup

License

Licensed under the Apache License, Version 2.0.

About

Autonomous AI-assisted development: takes GitHub Issues, develops via TDD, self-reviews, creates PRs, monitors CI, addresses feedback. CLI + web dashboard + scheduler.

Topics

Resources

Code of conduct

Contributing

Security policy

Stars

3 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages