Skillget

ccx-dotnet

skill
Security Audit
Pass
Health Pass
  • License — License: MIT
  • Description — Repository has a description
  • Active repo — Last push 0 days ago
  • Community trust — 20 GitHub stars
Code Pass
  • Code scan — Scanned 2 files during light audit, no dangerous patterns found
Permissions Pass
  • Permissions — No dangerous permissions requested
Purpose
This tool is a .NET-based CLI that acts as an AI coding assistant. Built for enterprise environments, it provides a terminal user interface to interact with AI models for code generation, file manipulation, and task execution.

Security Assessment
Overall risk: Medium. While the automated code scan passed with no dangerous patterns or hardcoded secrets found, the tool's core features inherently interact with sensitive systems. It explicitly executes shell commands (via its Bash tool) and makes external network requests to the Anthropic API using an environment variable. Additionally, it includes file editing, writing, and web fetching capabilities. Users must supply their own Anthropic API key, which the application manages locally. Because the tool is designed to autonomously read, write, and execute code, it carries an inherent risk of accidental file modification or unwanted command execution.

Quality Assessment
Quality appears solid. The project is licensed under the permissive and standard MIT license. It is highly active, with repository updates pushed as recently as today. While the community footprint is currently small (20 GitHub stars), indicating a newer or niche project, the focus on AOT-compilation, Spectre.Console TUI, and a test suite suggests a professional, well-structured codebase targeting enterprise .NET developers.

Verdict
Use with caution; the underlying code appears safe and well-maintained, but you should carefully monitor its permission system when allowing autonomous shell execution or file modifications.
SUMMARY

.NET implementation of an AI coding assistant CLI. AOT-compiled, Spectre.Console TUI, enterprise-focused.

README.md

ccx-dotnet

AI coding assistant CLI in .NET 10, part of the CCX (Community Code Extended) project. 7.9MB AOT binary, 11 tools, Spectre.Console TUI. The only AI coding CLI built on .NET, targeting enterprise environments.

Why CCX?

CCX (Community Code Extended) is a custom AI coding assistant built from the ground up using publicly documented API specifications and common patterns in AI-assisted development. Each implementation is its own application with independent architecture decisions and language-idiomatic designs.

ccx-dotnet fills a gap that nothing else does: there are zero AI coding CLIs built for the .NET ecosystem. Enterprise .NET shops running C#, F#, and Azure pipelines have no native option. This implementation brings AOT-compiled performance, Spectre.Console TUI, and the full tool system to the platform where a huge portion of enterprise code actually lives.

Unlike instructkr/claw-code (41.7k stars), which catalogs tool inventories as structured data, ccx-dotnet is a ground-up .NET implementation with real tool execution, DI-based architecture, and a comprehensive test suite.

Quick Start

git clone https://github.com/anton-abyzov/ccx-dotnet.git
cd ccx-dotnet
dotnet build
export ANTHROPIC_API_KEY="your-key-here"
dotnet run --project src/Ccx.Cli

Features

  • 11 built-in tools -- Bash, FileRead, FileEdit, FileWrite, Glob, Grep, Agent, WebFetch, NotebookEdit, TodoRead, TodoWrite
  • Slash commands with autocomplete -- /help, /compact, /clear, /model, /memory, /skills
  • Streaming responses -- HttpClient SSE streaming with IAsyncEnumerable and real-time tool_use handling
  • Markdown rendering -- Markdig with custom Spectre.Console renderer
  • Skill discovery -- loads and executes markdown-based skills
  • Task-based agent spawning -- CancellationToken and Channel for inter-agent IPC
  • 4-layer context compression -- with IAsyncEnumerable streaming
  • MCP protocol -- JSON-RPC over stdio/SSE
  • Permission system -- rule-based with interactive approval flows
  • Memory persistence -- user, project, feedback, and reference memory types
  • AOT-compatible -- single binary via dotnet publish -p:PublishAot=true

Slash Commands

Command Description
/help Show available commands
/compact Compress conversation context
/clear Clear conversation history
/model Switch Claude model
/memory View/manage memory entries
/skills List available skills
/config Show current configuration

Why .NET?

  • 7.9MB AOT binary via dotnet publish --self-contained -p:PublishAot=true
  • Strong async/await -- Task, IAsyncEnumerable for streaming, Channel for agent communication
  • Enterprise appeal -- .NET shops are underserved by AI CLI tools
  • Spectre.Console -- rich terminal rendering with tables, trees, panels, syntax highlighting
  • Uncontested niche -- zero AI coding assistants built on .NET
  • DI-first -- Microsoft.Extensions.DependencyInjection for clean architecture

Architecture

Based on publicly documented patterns in AI coding assistant architecture:

  • Tool System: Interface-based tools with DI registration and permission gating
  • Agent Spawning: Task-based with CancellationToken and Channel for inter-agent IPC
  • TUI: Spectre.Console with Live rendering, Markup, and interactive prompts
  • Context Management: Multi-layer compression with IAsyncEnumerable streaming
  • MCP Protocol: JSON-RPC over stdio/SSE
  • Permission System: Rule-based with interactive approval flows
  • Streaming API: HttpClient with ReadAsStreamAsync for SSE parsing

Tech Stack

Component Library
TUI Spectre.Console + Spectre.Console.Cli
HTTP/Streaming HttpClient (stdlib)
JSON System.Text.Json (source-generated)
Schema Validation JsonSchema.Net
CLI Parsing Spectre.Console.Cli
Markdown Markdig + custom Spectre renderer
Syntax Highlighting TextMateSharp
Config Microsoft.Extensions.Configuration
DI Microsoft.Extensions.DependencyInjection
Testing xUnit + FluentAssertions + WireMock.Net + Verify

Project Structure

src/
  Ccx.Cli/              # CLI entry point (AOT-compatible)
  Ccx.Core/             # Core agent loop and query engine
  Ccx.Api/              # Anthropic API client (streaming, tool_use)
  Ccx.Tools/            # Tool interface and built-in implementations
    Tools/
      BashTool.cs
      FileReadTool.cs
      FileEditTool.cs
      FileWriteTool.cs
      GlobTool.cs
      GrepTool.cs
      AgentTool.cs
      WebFetchTool.cs
  Ccx.Permissions/      # Permission DSL, rules, interactive prompts
  Ccx.Compact/          # 4-layer context compression
  Ccx.Memory/           # Memory system (user, project, feedback, reference)
  Ccx.Skills/           # Skill loading and execution
  Ccx.Mcp/              # MCP protocol client
  Ccx.Config/           # Settings cascade, CLAUDE.md parsing
  Ccx.Tui/              # Spectre.Console UI components
tests/
  Ccx.Core.Tests/
  Ccx.Api.Tests/
  Ccx.Tools.Tests/
  Ccx.Permissions.Tests/
  Ccx.Integration.Tests/

Getting Started

dotnet tool install -g ccx-dotnet

Development

git clone https://github.com/anton-abyzov/ccx-dotnet.git
cd ccx-dotnet
dotnet build
dotnet test

Requirements

  • .NET 10 SDK
  • AOT publishing requires platform-specific toolchain

License

MIT

Reviews (0)

No results found