Metadata-Version: 2.4
Name: sdlckit
Version: 0.2.1
Summary: SDLCKit — AI-governed SDLC lifecycle engine with SAGE loop
Author: SDLCKit Contributors
License-Expression: Apache-2.0
Project-URL: Homepage, https://github.com/atishio/sdlc-kit
Project-URL: Documentation, https://github.com/atishio/sdlc-kit#readme
Project-URL: Repository, https://github.com/atishio/sdlc-kit
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Programming Language :: Python :: 3.13
Classifier: Topic :: Software Development :: Quality Assurance
Requires-Python: >=3.11
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: pyyaml<7.0,>=6.0
Requires-Dist: jsonschema<5.0,>=4.0
Requires-Dist: referencing>=0.30.0
Requires-Dist: python-frontmatter>=1.0
Requires-Dist: filelock>=3.0
Provides-Extra: dev
Requires-Dist: pytest>=7.0; extra == "dev"
Dynamic: license-file

# SDLCKit

**Governed AI quality loops for every SDLC phase.**

![Beta](https://img.shields.io/badge/status-beta-blue)
![Python 3.11+](https://img.shields.io/badge/python-3.11%2B-blue)
![License: Apache 2.0](https://img.shields.io/badge/license-Apache%202.0-green)

SDLCKit wraps each phase of the software development lifecycle in a **SAGE loop** — a governed cycle where humans declare intent, AI produces artifacts, and independent scorers review against weighted quality dimensions. The result: measurable confidence in AI-generated artifacts before they reach production.

SDLCKit is a governance layer, not an SDLC. You keep your existing process and add SDLCKit on top.

---

## Why Governance?

AI agents can produce code, specs, and designs — but without governance, there is no measurable quality signal. SDLCKit provides that signal through four properties:

| Property | What It Means |
|----------|---------------|
| **Independent Scoring** | Scorer agent is sandboxed (read-only tools). Cannot collude with producer. |
| **Dimensional Confidence** | Not pass/fail. N weighted dimensions scored independently (e.g., clarity 0.35, completeness 0.30). |
| **Bounded Fix Loops** | Max N automated iterations. Oscillation detection stops thrashing. |
| **Human Gates** | Two-pass: (1) deterministic structural check, (2) human quality review with scorecard. |

---

## The SAGE Loop

Every phase — refine, architect, build, review — runs the same governed cycle:

```
  SCOPE                           SAGE LOOP
  +------------------+            +------------+
  | User input       |       +--->|  ANALYZE   |
  | Discovery output |       |    |  Frame goal + constraints   |
  | Feedback signals |------>+    +-----+------+
  | Prior state      |       |          |
  +------------------+       |          v
                             |    +------------+
                             |    | GENERATE   |
                             |    |  AI produces artifacts      |
                             |    +-----+------+
                             |          |
                             |          v
                             |    +------------+
                             |    | EVALUATE   |
                             |    |  Independent scorer scores  |
                             |    |  N weighted dimensions      |
                             |    +-----+------+
                             |          |
                             |     confidence < threshold?
                             |          |
                             |     YES: Fix Loop (target weakest dim)
                             |          |
                             |     NO:  Human Gate
                             |          |
                             |    [Approve] -> advance
                             |    [Revise]  -> feedback
                             +----[Pause]   -> save state
```

---

## Quick Start

### Prerequisites

- Python 3.11+
- [Claude Code](https://docs.anthropic.com/en/docs/claude-code)

### Install

```bash
pip install sdlckit
```

Installs the latest published release. To pin a specific version:

```bash
pip install sdlckit==0.2.0
```

### Initialize a Project

```bash
sdlckit init
```

Scaffolds your project: `sdlc.yaml`, skills, agents, templates, schemas, and the `/sdlc` slash command.

### Customize

After init, update these for your team:

- **`sdlc.yaml`** — lifecycle phases, scoring dimensions, thresholds, plugin config
- **`.sdlckit/conventions/`** — layered convention files loaded in sorted order:
  - `00-architecture.md` — diagram standards, naming, classDef palette (built-in)
  - `01-security-architecture.md` — trust zones, data classification (built-in)
  - `10-your-team.md`, `11-your-domain.md` — add your own with `10+` prefix

### Run a Phase

```bash
# In Claude Code:
/sdlc refine "user onboarding feature"
```

The SAGE engine produces `REFINE.md`, scores it across weighted dimensions, runs fix loops if below threshold, then presents the human gate.

### Check Status

```bash
/sdlc status
```

---

## Commands

**Slash commands** (in Claude Code):

| Command | What It Does |
|---------|-------------|
| `/sdlc <phase> "input"` | Run a phase with direct input |
| `/sdlc <phase>` | Run a phase (inputs auto-resolved from upstream) |
| `/sdlc <phase> amend "feedback"` | Re-enter a completed phase with feedback |
| `/sdlc status` | Lifecycle dashboard |
| `/sdlc reconcile` | Re-run stale phases after an amendment |
| `/sdlc signal list\|show\|dismiss\|inject` | Manage feedback signals |
| `/sdlc connectors` | View connector plugin status |

Phase commands are dynamic — a custom phase `compliance` in `sdlc.yaml` becomes `/sdlc compliance`.

**CLI commands:**

| Command | What It Does |
|---------|-------------|
| `sdlckit init [--type component\|initiative]` | Scaffold a project |
| `sdlckit assign <path>` | Import an assignment into a component repo |
| `sdlckit observe <title> --components <names>` | Record an operational observation |
| `sdlckit archive <name>` | Pre-merge cleanup (manifests, state) |
| `sdlckit --version` | Show installed version |

---

## Two Modes

**Component mode** (`sdlc.yaml`) — single project, linear phase sequence: refine -> architect -> build -> review.

**Initiative mode** (`sdlc-initiative.yaml`) — multi-component, multi-repo projects. Discovery and Delivery stages with per-component SAGE loops, stage reviews, knowledge extraction, and assignment handoffs.

---

## Extending with Plugins

SDLCKit separates **engine** (how the loop runs) from **domain knowledge** (what the loop produces). Plugins provide richer implementations:

- **Phase plugins** replace built-in phases with specialized skills, agents, dimensions, and templates
- **Connector plugins** deliver scored artifacts to external systems (Jira, CI/CD, etc.)

See the Developer Guide in the repository for plugin authoring.

---

## Roadmap

| Feature | Target |
|---------|--------|
| Checkpoint / resume (crash recovery) | v0.3 |
| SAGE-wrapped knowledge extraction | v0.3 |
| Connector plugin execution | v0.3 |
| `auto_advance` phase chaining | v0.3 |
| Plugin registry + remote sources | Post-1.0 |

---

## Documentation

The repository includes detailed guides:

- **Consumer Guide** — installation, configuration, daily usage
- **Contributor Guide** — engine internals, testing
- **Developer Guide** — building plugins, skills, agents, schemas
- **Architecture Reference** — SAGE engine, state management, plugin model, agent model

---

## License

Apache License 2.0
