clauderizer 0.2.0__tar.gz

clauderizer-0.2.0/.claude/settings.json

@@ -0,0 +1,14 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "uvx --from clauderizer clauderizer-hook"
+          }
+        ]
+      }
+    ]
+  }
+}

clauderizer-0.2.0/.claude/skills/clauderizer-amend/SKILL.md

@@ -0,0 +1,21 @@
+---
+name: clauderizer-amend
+description: Change a gameplan after it has started executing. Use when scope shifts mid-flight — a phase needs a task it's missing, a dependency changed, or work must be added/removed.
+---
+
+# Amend a gameplan
+
+First decide: **amend** or **new mini-gameplan**?
+
+- If you'd write the *same* Project Overview paragraph for the new work as the original → **amend**.
+- If a fresh overview makes more sense → start a separate gameplan (`cz_create_gameplan`).
+
+To amend:
+
+1. `cz_add_amendment` with the affected sections/phases, what changed, and why. It assigns the next `A-NNN` and references a cascade report.
+2. Run `cz_cascade` over the affected phases and reconcile:
+   - Unstarted phases: the next handoff picks up the change.
+   - In-progress: log it as a correction and reconcile mid-flight.
+   - Completed: if the finished work conflicts, add a revisit phase.
+
+Amendments are append-only — superseded ones stay with a note.

clauderizer-0.2.0/.claude/skills/clauderizer-cascade/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: clauderizer-cascade
+description: After changing a tracked entity (subsystem, feature, decision, invariant, or a status/version), walk its dependents and reconcile them. Use whenever you finish an edit that something else might depend on.
+---
+
+# Run cascade
+
+Cascade is **post-hoc and judgment-based**: it finds what *might* be affected; you decide what actually is.
+
+1. `cz_cascade(entity_id, transition)` — walks the Project DAG forward and writes a report listing direct + transitive dependents, each marked "needs review".
+2. Open each flagged dependent. Decide: affected or not?
+   - If affected: make the edit, then note it under "Updates applied".
+   - If not: note "no change needed".
+3. Resolve every "needs review" marker before the session ends — a report with unresolved markers shows up as a pending cascade in `cz_status` and fails the `cascade_hygiene` pre-flight check.
+
+Status transitions already trigger cascade via `cz_transition_status`; use this skill for manual triggers or to finish reconciling a report.

clauderizer-0.2.0/.claude/skills/clauderizer-close-gameplan/SKILL.md

@@ -0,0 +1,12 @@
+---
+name: clauderizer-close-gameplan
+description: Close out a completed (or explicitly deferred) gameplan. Use when all phases are done and the user wants to wrap up and capture what was learned.
+---
+
+# Close a gameplan
+
+1. Confirm every phase is complete or explicitly deferred (`cz_status`).
+2. Run a full cascade pass; resolve any pending reports.
+3. Update project-level docs (CHANGELOG, ARCHITECTURE, REQUIREMENTS) to reflect final state.
+4. Write a `POST-MORTEM.md` in the gameplan dir: what worked, what didn't (with root causes), and concrete improvements to the procedure. This is where the system itself gets better.
+5. Leave the gameplan directory on disk (nothing is deleted) and clear/replace `active_gameplan` in `.clauderizer/config.toml`.

clauderizer-0.2.0/.claude/skills/clauderizer-do-phase/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: clauderizer-do-phase
+description: Execute or continue the current gameplan phase end-to-end — pre-flight, do the work, then close out (handoff + status transitions + cascade). Use when the user says "do the next phase", "continue the gameplan", or "work on phase N".
+---
+
+# Execute a phase
+
+1. Call `cz_next_phase_context` to load the phase bundle (tasks, key files, lessons, exit criteria). Read the key files it lists.
+2. Call `cz_preflight`. If any enabled check fails, STOP and report — do not write code.
+3. Execute the phase tasks. Honor every rule in `CLAUDE.md` and the accumulated lessons.
+4. Closing protocol:
+   - Record outcomes: `cz_add_correction` for any divergence; `cz_add_lesson` for anything generalizable.
+   - For each subsystem/feature whose state changed, `cz_transition_status` (this fires cascade automatically when enabled).
+   - For any other tracked edit, run `cz_cascade` and fill in the report's "needs review" verdicts.
+   - `cz_write_handoff` for the next phase.
+   - Run exit verification (the host test/build commands) and report the final count.

clauderizer-0.2.0/.claude/skills/clauderizer-new-gameplan/SKILL.md

@@ -0,0 +1,13 @@
+---
+name: clauderizer-new-gameplan
+description: Plan a new multi-phase gameplan from a goal. Use when the user wants to start a new initiative, project, or large feature and needs it broken into phases with decisions and exit criteria.
+---
+
+# Start a gameplan
+
+1. Clarify the goal in one sentence with the user.
+2. Capture real source-of-truth values first (account IDs, versions, baseline test counts) — never invent them.
+3. `cz_create_gameplan` with a descriptive name. This becomes the active gameplan.
+4. Record the decisions that shape it with `cz_add_decision` (scope `gameplan` for tactical, `project` for architectural ADRs).
+5. Lay out phases with `cz_add_phase` — each session-sized (1–3 days), with a goal, dependencies, and verifiable exit criteria. 5–25 phases is typical.
+6. `cz_write_handoff` for Phase 0 so the first execution session is self-contained.

clauderizer-0.2.0/.claude/skills/clauderizer-record/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: clauderizer-record
+description: Quickly capture a decision, invariant, lesson, correction, or risk into the right place. Use when the user says "remember that…", "we decided…", "note that…", or "that was a mistake, the right way is…".
+---
+
+# Record to memory
+
+Route the capture to the correct tool so the graph stays consistent — never hand-edit the logs:
+
+- **A decision** ("we decided X because Y") → `cz_add_decision` (project-wide ADR, or scope `gameplan` for tactics).
+- **A rule that must always hold** → `cz_add_invariant`.
+- **A reusable lesson** → `cz_add_lesson` (pick a category; it rolls into every future handoff).
+- **A divergence from the plan** → `cz_add_correction` (optionally promote a `lesson` in the same call).
+- **A persistent risk** → record under `docs/HARDENING.md` (append-only; never delete entries).
+- **A new subsystem/feature/external service** → `cz_upsert_entity`.

clauderizer-0.2.0/.clauderizer/config.toml

@@ -0,0 +1,22 @@
+[clauderizer]
+version = "1"
+size = "standard"
+preflight_checks = ["branch_base", "clean_tree", "tests", "build", "deps_spotcheck", "branch_creation", "cascade_hygiene"]
+
+[host]
+profile = "python"
+
+[paths]
+docs = "docs"
+gameplans = "docs/gameplans"
+
+[modules]
+enabled = ["VISION", "ARCHITECTURE", "DECISIONS", "INVARIANTS", "TESTING", "HARDENING"]
+
+[rituals]
+preflight = true
+cascade = true
+amendments = false
+
+[active_gameplan]
+id = "2026-05-30-clauderizer-v1-bootstrap"

clauderizer-0.2.0/.clauderizer/profile.lock.toml

@@ -0,0 +1,10 @@
+profile = "python"
+
+[commands]
+test = "pytest -q"
+build = ""
+lint = "ruff check ."
+typecheck = "mypy ."
+
+[preflight]
+baseline_test_regex = "(\d+) passed"

clauderizer-0.2.0/.github/workflows/publish.yml

@@ -0,0 +1,41 @@
+name: Publish to PyPI
+
+# Publishes when you cut a GitHub Release. Uses PyPI Trusted Publishing (OIDC) —
+# no API token or secret is stored anywhere. Configure the trusted publisher once
+# on PyPI (see "Publishing" in the README): project `clauderizer`, owner
+# `collincusce`, repo `Clauderizer`, workflow `publish.yml`, environment `pypi`.
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+      - run: uv build
+      - run: uvx twine check dist/*
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/clauderizer
+    permissions:
+      id-token: write   # required for Trusted Publishing
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1

clauderizer-0.2.0/.github/workflows/test.yml

@@ -0,0 +1,20 @@
+name: Tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python: ["3.10", "3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+      - run: uv venv --python ${{ matrix.python }}
+      - run: uv pip install -e ".[mcp,dev]"
+      - run: uv run pytest -q

clauderizer-0.2.0/.gitignore

@@ -0,0 +1,24 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+build/
+dist/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+
+# Virtualenvs
+.venv/
+venv/
+env/
+
+# Clauderizer disposable cache (rebuilt from markdown)
+.clauderizer/index.json
+
+# Local Claude Code settings
+.claude/settings.local.json
+
+# OS
+.DS_Store

clauderizer-0.2.0/.mcp.json

@@ -0,0 +1,12 @@
+{
+  "mcpServers": {
+    "clauderizer": {
+      "command": "uvx",
+      "args": [
+        "--from",
+        "clauderizer",
+        "clauderizer-mcp"
+      ]
+    }
+  }
+}

clauderizer-0.2.0/CHANGELOG.md

@@ -0,0 +1,67 @@
+# Changelog
+
+All notable changes to Clauderizer are documented here.
+
+## [0.2.0] — 2026-06-05
+
+First release published to PyPI.
+
+### Packaging
+- Fixed the wheel build: removed a `force-include` table that collided with
+  `packages`, which broke `uv build` / `python -m build`. The `templates/`,
+  `profiles/`, and `skills/` data dirs are bundled via `packages` and verified
+  present in the wheel.
+- Core install is dependency-free; the MCP server is the `clauderizer[mcp]` extra.
+
+### Added
+- `cz_add_finding` / `mutations.add_finding` (alias `add_risk`) — record structured
+  security/audit findings into the append-only `HARDENING.md` tracker.
+- `doctor` now probes that the MCP server **and** SessionStart hook commands are
+  actually executable, not just registered — a green check on a non-launchable
+  setup is worse than no check.
+- `detect.load_for_repo()` overlays a project-local `profile.lock.toml`, so
+  per-project test/build/lint/typecheck overrides take effect (the lock was
+  previously write-only).
+
+### Changed
+- `init` wiring now prefers installed console scripts (venv/pipx) and only falls
+  back to `uvx`, fixing the Windows→WSL / venv drop-in path.
+- Re-running `init` with a changed invocation now **replaces** the SessionStart
+  hook instead of appending a duplicate.
+- `cz_next_phase_context` is side-effect-free: it assembles the handoff in memory
+  (`handoff.assemble(..., write=False)`) and returns it as `handoff_md`; only
+  `cz_write_handoff` persists a file.
+- The first real entry in a doc section now replaces the scaffold `_(…)_`
+  placeholder instead of stacking beneath it.
+
+### Fixed
+- SessionStart hook errors print to stdout (visible in session context) instead
+  of stderr, where silent failure was the dangerous kind.
+
+## [0.1.0] — 2026-05-30
+
+Initial release. A drop-in, MCP-native successor to the markdown "gameplan
+system": same conceptual model (gameplan → phase → task, a long-lived Project
+DAG, post-hoc cascade, cumulative handoffs, append-only memory), delivered as an
+active system instead of a procedure followed by hand.
+
+### Added
+
+- **Markdown core** — zero-dependency frontmatter parser, section/marker editing,
+  and a single idempotent mutation path (`markdown/writer.py`).
+- **Project DAG** — graph index (cached to a disposable `index.json`), dependent/
+  dependency queries, and semver pin-violation detection.
+- **Cascade** — post-hoc forward walk that writes a judgment-based report
+  (dependents marked "needs review"). Replaces the never-built `bin/cascade`.
+- **Rituals as operations** — `preflight` (the 7 checks run for real against host
+  profile commands), cumulative `handoff` assembly, and the `status` digest.
+- **Structured mutations** — decisions, invariants, lessons, corrections,
+  gameplans, phases, amendments, entities, and status transitions (auto-cascade).
+- **MCP server** — 15 self-describing tools + resources over stdio (optional
+  `mcp` extra).
+- **Configurability** — `pet` / `standard` / `saas` size dial and host-language
+  profiles (Node, Python, Go, Ruby, generic) as pure data.
+- **Drop-in** — `clauderize init` (idempotent), `status`, `doctor`, `reindex`,
+  `mcp`; a SessionStart hook for automatic cold-start; six Claude Code skills.
+- Test suite: 57 tests covering markdown round-trips, the graph, cascade,
+  rituals, mutations, init idempotency, profiles, and the live MCP tools.

clauderizer-0.2.0/CLAUDE.md

@@ -0,0 +1,24 @@
+<!-- clauderizer:start -->
+## Clauderizer
+
+This repo uses **Clauderizer** for durable, cross-session working memory. Markdown
+under `docs/` is the source of truth; an MCP server exposes it as live tools.
+
+**Start of every session**: the SessionStart hook injects current gameplan status
+into context automatically — no manual reading order. To refresh on demand, call
+`cz_status`. To begin/continue a phase, call `cz_next_phase_context` then
+`cz_preflight`.
+
+**Key tools** (MCP server `clauderizer`):
+- `cz_status` / `cz_next_phase_context` — where things stand; the next phase bundle.
+- `cz_graph_query` — look up an entity and its dependents/dependencies.
+- `cz_preflight` — run the pre-flight checks (tests/build via the host profile).
+- `cz_cascade` — after a tracked edit, walk dependents and write a cascade report.
+- `cz_write_handoff` — assemble the next cumulative phase handoff.
+- `cz_add_decision` / `cz_add_invariant` / `cz_add_lesson` / `cz_add_correction`
+  / `cz_upsert_entity` / `cz_transition_status` — structured, graph-aware writes.
+
+**Rules**: never hand-edit frontmatter or append to tracked logs directly — use the
+`cz_*` tools so the graph stays consistent. The procedure spec is at
+`docs/gameplans/GAMEPLAN-PROCEDURE.md`.
+<!-- clauderizer:end -->

clauderizer-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Clauderizer contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.