wingetCollections
  • Auto
  • Search
  • Awesome Collections
  • Awesome Programs
  • My Favorite Collections
  • My Collections
  • Account / Settings
  • Terms of Service
  • Privacy
  • About

© 2026 winget.ragerworks.com

Loading...
Install Kaizen CLI using Winget - wingetCollections
  1. Go back
  2. Packages
  3. Kaizen CLI
Kaizen CLI logo

Kaizen CLI Kaizen 3C

adr ai architecture cli llm memory-safety modernization refactoring rust
Use this command to install Kaizen CLI:
winget install --id=Kaizen3C.KaizenCLI -e

Kaizen CLI is an architecture-driven modernization tool designed to decompose legacy codebases into editable Architectural Decision Records (ADRs) and recompose them into modern software stacks. It provides an audit trail by default, ensuring compliance and maintainability throughout the modernization process.

Key Features:

  • Memory-Safety Roadmaps: The kaizen memsafe-roadmap workflow generates CISA-format memory-safety roadmaps for migrating C/C++ codebases to Rust.
  • Framework Modernization: The kaizen migrate-plan workflow supports transitioning from legacy frameworks like AngularJS, .NET Framework, and Java 8 to modern stacks such as Angular/React, .NET 8/9, and Java 17/21.
  • AI Integration: Requires an API key for Anthropic or OpenAI (or a local Ollama host) to leverage large language models (LLMs) for generating ADRs and modernization plans.

Audience & Benefit:

Ideal for software architects, developers, and organizations aiming to modernize legacy systems while ensuring compliance and maintainability. Kaizen CLI helps teams produce auditable architectural decisions that guide modernization efforts, reducing technical debt and improving code quality. The tool is particularly beneficial for projects requiring memory-safety improvements or framework upgrades.

Kaizen CLI can be installed via winget (Windows) as a standalone binary.

README

Kaizen

Architecture-driven modernization. Audit trail ships by default. Decompose legacy codebases into editable ADRs, recompose to modern stacks — compliance falls out of doing the architecture right, not bolted on after.

License: Apache 2.0 License: Commercial Python Status

Install

MethodCommand
winget (Windows)winget install Kaizen3C.KaizenCLI
npmnpm install -g kaizen-3c-cli
Homebrew (macOS/Linux)brew tap Kaizen-3C/tap && brew install kaizen-cli
pipx (Python, recommended)pipx install kaizen-3c-cli
uvuv tool install kaizen-3c-cli
pippip install kaizen-3c-cli

winget, npm, and Homebrew install a standalone binary (no Python required). pipx/uv/pip install the full package including [web] and [mcp] extras.

export ANTHROPIC_API_KEY=...     # or OPENAI_API_KEY, or a local Ollama host
kaizen memsafe-roadmap ./my-c-lib --output roadmap.md

Does it work? — measured outcomes

Case studyOne-shot LLMKaizen (plain ADR)Kaizen (+ domain schema)
inih — C → Rust, 522 LOC (cargo check)6 errors
Versions
1.0.1
Website
github.com
License
Last updated
5/15/2026
Download latest version
1 error
0 errors
Nancy — NancyContext.cs .NET Fx → .NET 8, 148 LOC (dotnet build)14 errors0 errors0 errors

Methodology: three-arm ablation (one-shot control, plain ADR pipeline, ADR + domain schema) on real OSS repos. Exact commands, prompts, and raw outputs in each case-study directory.

What it isn't

Kaizen is not a code-generation tool. The ADR is the product; the LLM is the tool that produces it. An ADR is an editable, auditable record of an architectural decision — the thing a compliance officer signs off on, the thing a reviewer pushes back on, the thing that survives when the model changes next quarter. Recompose is the CI check that the ADR actually predicts working code.

The two wedges

  • kaizen memsafe-roadmap — C/C++ → Rust. Produces a CISA-format memory-safety roadmap + per-module ADR stubs. Optionally recomposes to a Rust port.
  • kaizen migrate-plan --from X --to Y — framework modernization (9 pairs: AngularJS → Angular/React, jQuery → React, .NET Framework → .NET 8/9, Python 2 → 3, Java 8 → 17/21, Spring 4 → Spring Boot 3).

Full CLI reference: cli/README.md.

License

Kaizen is dual-licensed:

  • Apache-2.0 for the CLI, pipeline, and provider adapters — cli/, cli/pipeline/, agents/src/providers/. Free forever. Installable via pip install kaizen-3c-cli.
  • Kaizen Enterprise Commercial for the enterprise wrapper — multi-tenancy, RBAC, SSO, MFA, audit-log export, approval workflows, cost attribution UI, budget caps. Lives under interface/ and is priced in docs/commercial/PRICING.md.

The open-core boundary is explicit and enumerated in ADR-0053. No pipeline capability is paywalled — the commercial tier wraps infrastructure, not pipeline. Validated in docs/CLI_VS_UI_CAPABILITY_REVIEW.md.

Documentation

  • Quickstart
  • CLI guide — task-focused walkthrough of every command + the lite web UI
  • CLI reference — full flag reference
  • Case studies — reproducible measurements

Contributing

Contributions are welcome. See CONTRIBUTING.md. All Apache-2.0 inbound; Commercial-tier work happens in the private dev repo, not via public PRs. Code of Conduct: CODE_OF_CONDUCT.md.

Security

To report a vulnerability, follow SECURITY.md. Do not open a public issue for security-related findings.

For contributors — internals

Architecture

Kaizen uses a four-tier architecture with a multi-agent denoising convergence loop. The CLI + pipeline (top-left in the diagram) is the Apache-2.0 surface; the ASP.NET + React UI is the Commercial wrapper.

┌─────────────────────────────────────────────────────┐
│  React / TypeScript UI  (interface/ui/)             │  ← Commercial
│  Vite, Zustand, TanStack Query, Monaco, Recharts    │
└────────────────────┬────────────────────────────────┘
                     │ REST / HTTP
┌────────────────────▼────────────────────────────────┐
│  C# / ASP.NET Core 9 API  (interface/)              │  ← Commercial
│  PostgreSQL, Redis, JWT + MFA                       │
└────────────────────┬────────────────────────────────┘
                     │ gRPC (deferred — see ADR-0061)
┌────────────────────▼────────────────────────────────┐
│  Rust Orchestrator  (core/)                         │  ← Apache (deferred modules)
│  Concurrent decomposition engine, convergence gate  │
└────────────────────┬────────────────────────────────┘
                     │ in-process / gRPC
┌────────────────────▼────────────────────────────────┐
│  Python Agent Services  (cli/, agents/)             │  ← Apache — the shipped product
│  Researcher, Red Team, Draft, Write, Evaluator      │
│  LLM provider abstraction (Anthropic, OpenAI,       │
│  Ollama, LiteLLM)                                   │
└─────────────────────────────────────────────────────┘

The five agents (Researcher, Red Team, Draft, Write, Evaluator) iterate over the decomposition output. Each round produces grounded confidence scores (test pass rate, static analysis, coverage); the orchestrator gates completion via a Thompson-sampling convergence decision (see ADR-0052).

Developer setup

See quickstart.md for environment prerequisites, Docker Compose setup for the full stack, and first-run instructions. For CLI-only development, pip install -e . at the repo root is enough.