Metadata-Version: 2.4
Name: llmflow-cli
Version: 0.1.1
Summary: Deploy /implement workflow templates for Claude and Gemini AI assistants
Project-URL: Homepage, https://github.com/mxdumas/llm-workflow
Project-URL: Repository, https://github.com/mxdumas/llm-workflow
License-Expression: MIT
Keywords: ai,claude,gemini,implement,templates,workflow
Classifier: Development Status :: 3 - Alpha
Classifier: Environment :: Console
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Topic :: Software Development
Requires-Python: >=3.10
Requires-Dist: httpx>=0.25.0
Requires-Dist: pyyaml>=6.0
Requires-Dist: rich>=13.0
Requires-Dist: typer>=0.9.0
Provides-Extra: dev
Requires-Dist: pre-commit>=3.0; extra == 'dev'
Requires-Dist: pytest-cov>=4.0; extra == 'dev'
Requires-Dist: pytest>=7.0; extra == 'dev'
Requires-Dist: ruff>=0.1.0; extra == 'dev'
Description-Content-Type: text/markdown

# llm-flow

**Deploy the `/implement` workflow templates to Claude and Gemini.**

`llm-flow` is a small CLI that installs a consistent, opinionated software-development workflow (Analyze → Design → Gate → Implement → Tests → Review → Done) into your AI coding assistants. The workflow tracks state in Jira via the MCP — not via a Python backend.

## What it does

- Deploys `commands/implement.md` + `commands/implement/init/*.md` into `.claude/commands/` and `.gemini/commands/` of a project or user directory.
- Converts Markdown to Gemini TOML automatically.
- Works cross-OS (Linux, macOS, Windows).
- Supports updating templates from GitHub without reinstalling the package.

## What it does **not** do

- It does not call Jira directly. The `/implement` templates instruct your LLM (Claude, Gemini) to use **your MCP Jira server** for all ticket operations (status, labels, comments, search). Configure your MCP separately in your assistant's settings.
- It does not adapt to a specific programming language. Templates are language-agnostic — build/test/lint commands come from each project's own `CLAUDE.md`.

## Installation

```bash
pip install llmflow-cli
```

## Quick start

```bash
# First run triggers an interactive setup wizard (target, platforms)
llm-flow setup

# Deploy into the current project (.claude/, .gemini/)
llm-flow deploy

# Or deploy into user-level directories (~/.claude/, ~/.gemini/)
llm-flow deploy --target user

# Preview what would happen
llm-flow deploy --dry-run

# Update templates from GitHub, then deploy
llm-flow deploy --update

# Show or modify configuration
llm-flow config --show
llm-flow config --set-target user
```

## Configuration

Two levels:

- **Global** (user-level): `~/.config/llm-flow/config.yaml` (Linux/macOS) / `%APPDATA%\llm-flow\config.yaml` (Windows).
- **Project** (`./.llm-flow.yaml`): overrides global settings for a specific repo.

Schema is minimal:

```yaml
default_target: project        # or "user"
platforms:
  - claude
  - gemini
```

Coverage thresholds, language choices, or Jira credentials are **not** managed by `llm-flow` — they belong in each project's own `CLAUDE.md` and in your MCP Jira server configuration respectively.

## Updating templates

Templates are bundled with the installed wheel, but you can pull newer versions from GitHub without reinstalling:

```bash
llm-flow update            # fetch latest
llm-flow update --force    # re-download everything
llm-flow deploy --update   # update then deploy
```

Cache location: `~/.config/llm-flow/templates/` (or `%APPDATA%\llm-flow\templates\`).

## CLI reference

| Command | Role |
|---------|------|
| `llm-flow version` | Show version |
| `llm-flow setup` | First-time interactive setup wizard |
| `llm-flow init` | Create a `.llm-flow.yaml` in the current project |
| `llm-flow config [--show] [--set-target X] [--set-platforms X,Y]` | Inspect or edit configuration |
| `llm-flow deploy [--target] [--platform] [--dry-run] [--force] [--update] [--no-cache] [--quiet]` | Deploy templates |
| `llm-flow update [--force] [--quiet]` | Pull latest templates from GitHub into the cache |

## The `/implement` workflow

Once deployed, use these commands from Claude or Gemini:

| Command | Role |
|---------|------|
| `/implement` | Main continuous flow (phases 1–6) |
| `/implement:init:1-project` | Discovery conversation, initialize Jira epics and tickets |
| `/implement:init:2-architecture` | Define technical architecture |
| `/implement:init:3-standards` | Define code conventions |

Phases set a label on the Jira ticket (via your MCP): `phase:analyze`, `phase:design`, `phase:impl`, `phase:tests`, `phase:review`, `phase:done`. Status transitions (To Do → In Progress → Done) are separate and happen at the start of Phase 1 and the end of Phase 6.

All ticket types are supported (Story, Bug, Task, Subtask, etc.).

## MCP Jira

`llm-flow` assumes your LLM has an MCP Jira server configured. The templates invoke it in natural language ("via the MCP Jira, fetch the next ticket of epic X") — no specific tool names are hardcoded, so any MCP Jira implementation works.

Configure your MCP Jira in your Claude/Gemini settings separately.

## Development

```bash
git clone https://github.com/mxdumas/llm-workflow
cd llm-workflow
python -m venv .venv && source .venv/bin/activate
pip install -e ".[dev]"

pytest -v
ruff check src/
ruff format src/
```

The templates live at `commands/` at the repo root. Editing them in place, then running `llm-flow deploy --no-cache` in a test project is the fastest feedback loop.

## License

MIT
