habit-hooks 1.0.0__tar.gz

habit_hooks-1.0.0/.github/dependabot.yml

@@ -0,0 +1,22 @@
+version: 2
+updates:
+  - package-ecosystem: uv
+    directory: /
+    schedule:
+      interval: weekly
+    groups:
+      uv-minor-patch:
+        dependency-type:
+          - production
+          - development
+        update-types:
+          - patch
+          - minor
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: weekly
+    groups:
+      github-actions:
+        patterns:
+          - "*"

habit_hooks-1.0.0/.github/workflows/ci.yml

@@ -0,0 +1,27 @@
+name: CI
+on:
+  push:
+    branches: [main]
+  pull_request:
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - name: Setup uv
+        uses: astral-sh/setup-uv@d0cc045d04ccac9d8b7881df0226f9e82c39688e # v6.8.0
+        with:
+          python-version: "3.11"
+      - name: Install dependencies
+        run: uv sync --frozen
+      - name: Setup Node
+        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
+        with:
+          node-version: '22'
+      - name: Install Node tool deps
+        run: |
+          npm ci --prefix plugins/typescript
+          npm ci --prefix plugins/generic
+      - name: Test
+        run: uv run pytest

habit_hooks-1.0.0/.github/workflows/dependabot-auto-merge.yml

@@ -0,0 +1,19 @@
+name: Dependabot auto-merge
+on: pull_request
+jobs:
+  auto-merge:
+    if: github.actor == 'dependabot[bot]'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+    steps:
+      - name: Fetch metadata
+        id: meta
+        uses: dependabot/fetch-metadata@25dd0e34f4fe68f24cc83900b1fe3fe149efef98 # v3.1.0
+      - name: Enable auto-merge for patch and minor updates
+        if: steps.meta.outputs.update-type == 'version-update:semver-patch' || steps.meta.outputs.update-type == 'version-update:semver-minor'
+        run: gh pr merge --auto --squash "$PR_URL"
+        env:
+          PR_URL: ${{ github.event.pull_request.html_url }}
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

habit_hooks-1.0.0/.github/workflows/release.yml

@@ -0,0 +1,48 @@
+name: release
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+      - name: Build every workspace package
+        run: uv build --all-packages --out-dir dist
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: ${{ matrix.environment }}
+    permissions:
+      id-token: write
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - { dist: habit_hooks, environment: pypi }
+          - { dist: habit_hooks_generic, environment: pypi-generic }
+          - { dist: habit_hooks_python, environment: pypi-python }
+          - { dist: habit_hooks_typescript, environment: pypi-typescript }
+          - { dist: habit_hooks_php, environment: pypi-php }
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - name: Isolate this package's distributions
+        run: |
+          mkdir -p upload
+          mv "dist/${{ matrix.dist }}-"*.whl "dist/${{ matrix.dist }}-"*.tar.gz upload/
+      - uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: upload/
+          skip-existing: true

habit_hooks-1.0.0/.gitignore

@@ -0,0 +1,20 @@
+# Per-plugin Node tool deps (installed via npm ci; see plugins/*/package.json)
+node_modules/
+dist
+coverage
+.DS_Store
+.idea
+.claude-channel/
+*.tgz
+*.log
+.vscode/
+.venv/
+__pycache__/
+*.pyc
+.pytest_cache/
+.spec-runs/
+
+/ruff.toml
+
+# Workflow orchestration script (run from ~/.claude, never a repo deliverable)
+.claude/workflows-build-overnight.js

habit_hooks-1.0.0/.jscpd.json

@@ -0,0 +1,6 @@
+{
+  "path": ["src"],
+  "ignore": ["**/*.test.ts", "tests/fixtures/**", "dist/**", "node_modules/**"],
+  "threshold": 0,
+  "minLines": 5
+}

habit_hooks-1.0.0/CHANGELOG.md

@@ -0,0 +1,68 @@
+# Changelog
+
+## Unreleased
+
+### Sensors & languages
+- **Consumer-defined sensors** (#16): the `sensors` config map is now the single way sensors are assembled — built-in and custom alike. Each entry is one of three mutually exclusive modes: `use` (reference a bundled sensor by id — `eslint`/`comment`/`jscpd`/`knip`/`ruff`/`deptry`/`line-count`/`needs-extraction`), a **wrapper script** (`command` + `produces` printing bag JSON), or a **declarative adapter** (`command` + `produces` + `items`/`fields`/`group`/`map`). The sensor id is the map key; `dependsOn` wires multi sensors. See `docs/sensors.md`.
+- **Authoritative `sensors` semantics**: when `sensors` is present it replaces the language preset entirely (no merge), so removing a built-in is just deleting its entry. When `sensors` is absent the preset is used and a deprecation warning is emitted — this implicit fallback is **removed in the 1.0.0 release**.
+- **Consumer-defined languages** (#16): `language` accepts any string. The built-ins (`typescript`/`python`) keep their preset + default file globs; any other value relies on the open `files` discovery globs plus a `sensors` map. A non-built-in language with no `files` emits a warning and discovers no source files.
+- A custom sensor must be declared as a pair — its `sensors.<id>` entry **and** a matching `smells.<smell>` entry (a custom smell needs `id` + `source: "custom"` + `severity`). New config validation rejects malformed sensor specs (mode mixing, missing required fields) and bad `files` globs.
+
+## 0.2.0
+
+### Highlights
+- Habit Hooks is now a smell-agnostic, config-driven coach: a three-stage pipeline (sensor → mapper → guide) connected by a JSON bag. Sensors detect findings and translate them into a canonical, tool-independent **smell vocabulary**; the mapper routes each smell to a fix; the guide coaches the agent and sets the exit code.
+- Two language presets ship out of the box — **TypeScript/JavaScript** (ESLint + knip + jscpd + a ts-morph comment scan) and **Python** (ruff + jscpd + deptry + a line-count sensor). No sensors run by default; `init` enables the preset for the project's language.
+- The smell catalogue, language presets, and per-language tool config drive behaviour. Concrete smell knowledge lives only in config and the language initializers — the runner, mapper, sensors, and checks are smell-agnostic.
+
+### CLI & config
+- `habit-hooks` runs the configured sensors over a project, groups findings by smell, prints each smell's coaching, and sets the process exit code — non-zero when an enforced smell fires, zero on a clean run or suggested-only findings.
+- Git-aware scope flags restrict a run to a change set: `--last <n>` (files changed in the last N commits), `--branch [name]` (vs a branch, default `scope.branchBase`), `--since <hash>` (since a commit), and `--all` (force every file). The four are mutually exclusive; the default scope and per-rule `changedFilesOnly` come from config. `--config <path>` points at an explicit config file; `--version` prints the version.
+- `habit-hooks.config.{ts,js,mjs}` is intentionally small: per-smell/per-rule `include`/`exclude` globs, `severity` overrides, `disabled`, and `changedFilesOnly`; a `scope` block (`onlyChangedFiles`, `branchBase`); a `prompts` directory for custom/override coaching text; and `commentCheck` thresholds. All tool thresholds stay in the consumer's own eslint/knip/jscpd/ruff config.
+
+### Wrap model & coaching
+- Habit Hooks drives the consumer's **own** installed eslint / knip / jscpd, surfacing whatever rules and thresholds those configs define; it falls back to the bundled binaries only when the project has none. The coaching layer (why-it's-a-smell + how-to-fix) is what Habit Hooks adds on top.
+- The bundled coaching prompts for the size/complexity smells are adapted from the refakts refactoring-quality system — keeping its analyse-first / anti-mechanical-fix structure — with the remaining prompts explaining why each smell matters rather than restating the threshold.
+- knip 5 and 6 are both supported: the consumer's installed major version is auto-detected so v5's `classMembers` and v6's per-issue `files`/`exports`/`dependencies` shapes are each read correctly, and v6 no longer loses every knip check over a rejected flag.
+
+### Smell catalogue
+- A canonical, tool-independent catalogue (kebab-case keys, see `docs/smell-vocabulary.md`). `enforced` smells fail the run (exit 1); `suggested` smells coach but exit 0; the mapper config can override severity per project.
+- Enforced size/complexity smells: `oversized-function`, `too-many-parameters`, `high-complexity`, `deep-nesting`, `oversized-file`.
+- Enforced correctness smells: `unused-variable`, `loose-equality`, `var-declaration`, `non-const-binding`, `duplicate-import`, `redundant-type-annotation`, and the unused-code family from knip/deptry (`unused-file`, `unused-export`, `unused-dependency`, `unused-class-member`, `unused-import`).
+- Suggested smells: `warning-comment`, `explicit-any`, `non-null-assertion`, `non-essential-comment`, `duplicated-code`.
+- `needs-extraction` (enforced) is a **composite** smell; `parse-error` (enforced) is a supplemental smell for ESLint fatals with no catalogue rule.
+- Each sensor owns its raw rule ID → smell translation; the mapper and prompts only ever key off the canonical smell, never the tool.
+
+### Sensors & presets
+- **TypeScript/JavaScript preset**: ESLint (size/complexity/correctness/TS smells + `parse-error`), knip (`unused-file`/`unused-export`/`unused-dependency`/`unused-class-member`), jscpd (`duplicated-code`), and an in-process ts-morph scan (`non-essential-comment`). `comment-check` still runs in-process via ts-morph — it is not a shell-out sensor.
+- **Python preset**: ruff (`high-complexity`/`too-many-parameters`/`oversized-function`/`unused-variable`/`unused-import`), jscpd on `.py` (`duplicated-code`), deptry (`unused-dependency`), and a language-agnostic line-count sensor (`oversized-file`).
+- Preset thresholds come from the consumer's own tool config (e.g. ESLint `max-lines`/`complexity`, ruff `mccabe.max-complexity`/`pylint.max-args`), not from Habit Hooks.
+- **Composite sensors via `dependsOn`** (#17): a multi sensor declares the smells it consumes, receives their issues in `ctx.deps`, and emits a derived smell. `needs-extraction` fires when one file is both `oversized-file` **and** `duplicated-code`. It augments by default (all three smells show); `needsExtraction.replace: true` suppresses the two inputs so only `needs-extraction` remains. The augment-vs-replace switch runs in the sensor stage, keeping the mapper a pure single-smell function. Wired into the TS preset and the Python preset.
+- **deep-nesting** (#26): new enforced TS smell via ESLint `max-depth`. Python `deep-nesting` (ruff `PLR1702`) is deferred while that rule is preview/unstable.
+- **Python `oversized-file`** (#19): a language-agnostic line-count sensor emits it for files over a threshold (`max-module-lines`, default 200). ruff has no `C0302` port and rejects an unknown `max-module-lines` key under `[tool.ruff]`, so the threshold is read by a no-TOML-parser text scan of the consumer's ruff config + `pyproject.toml`; set it in a ruff-ignored location such as `[tool.habit-hooks]`.
+- **`command` fix action** (#18): a smell's fix can be a script instead of a prompt. The guide runs the command once per smell that has issues, streams its output into that smell's section, and folds its exit code into the run's exit code.
+- **Declarative adapter**: a tool that already emits JSON can be wired as a sensor by declaring how to read it (`group`/`items`/`fields`/`map`, up to two levels of array nesting) — no wrapper script needed. Anything it can't express falls back to a wrapper script.
+- **Sensor failures fail the run** (#25): a sensor spawn/timeout failure now exits 1 (instead of a false-clean) while still rendering every successful sensor's output. Failures travel on a shared `SensorSink`; the failure notice is shown on stderr.
+
+### Baseline, snooze & auto-prune
+- A file-level baseline (snooze) is committed to the repo at `.habit-hooks-baseline.json`, so a whole team shares one snapshot of legacy violations. A snoozed file stays snoozed for every sensor only while it appears in the baseline, its last-commit hash matches, and its working tree is clean — touching the file re-arms every smell, so you cannot silently drift past snoozed violations.
+- `habit-hooks baseline` subcommands manage it: `generate` (record current violations), `status` (list snoozed files and freshness), `snooze <files...>`, `forget <files...>`, and `prune` (drop stale/resolved entries).
+- **Auto-prune of dead snooze entries** (#11): on a full-repo run, Habit Hooks re-scans baseline-free and reaps snooze entries whose file is present but no longer produces the smell, printing the pruned set. Scoped runs never mutate the baseline (a file can look clean only because its smell is outside the diff), so they are a guaranteed no-op. Auto-prune shares one reaper with the manual `baseline prune` command.
+- A memoized, batched snooze index collapses the per-rule git spawns to O(1) status + O(files) memoized log calls.
+
+### Init
+- `habit-hooks init [language]` onboards a project for its language. With no argument it detects the language and prints a report-only message; an explicit language threads through with no re-detect, and an unsupported language exits 2 before any side effect.
+- Detects which tools are already installed/configured and scaffolds starter configs only for the missing pieces: an ESLint flat config (TS) or `ruff.toml` + `.jscpd.json` (Python), with package-manager install commands spanning pip and node ecosystems.
+- The scaffolded ESLint config writes tunable thresholds including `max-depth: 4` (deep-nesting) alongside the other size/complexity rules, and exempts test files from size rules. Test globs derive from a single shared exclude list.
+- Recommended thresholds mirror across languages from one source (ESLint `complexity 10` / `max-params 3` ↔ ruff `mccabe.max-complexity 10` / `pylint.max-args 3`); a freshly-scaffolded config is pinned to satisfy the drift check.
+- Drift detection is additive — a recommended value is flagged only when its key is absent, never when you've tuned it. `--accept-recommendations` runs the install commands and additively merges absent recommended keys into Habit-Hooks-owned config, never overwriting user values or editing user-owned `ruff.toml`/`pyproject.toml`/ESLint config.
+- Prompts cover package.json scripts, a pre-commit hook, and the bundled `habit-hooks-review` skill. `--dry-run` prints every intended write without touching disk.
+
+### Architecture
+- **Config-driven, smell-agnostic** (#24): all tool/smell knowledge lives in `src/config/tool-smells.ts` — the ESLint raw→smell map, the eslint/knip/jscpd/comment `produces`, and the ruff + deptry adapter specs. ESLint/jscpd/comment data is **derived from the catalogue**, so adding a smell there auto-wires its translation and produces; the runner, sensors, checks, and rules registry import these instead of hardcoding any smell id. `deep-nesting` (#26) was added by touching only the catalogue and the init ESLint template — the live proof of #24.
+- Single source for tool config discovery: `TOOL_CONFIG_FILENAMES` / `TOOL_PACKAGE_JSON_KEYS` in `src/detect/tool.ts`.
+- A routed smell with no tuned `<smell>.md` template falls back to a generic `uncoached.md` body while keeping its severity; a truly unknown smell (no routing at all) goes to the uncoached bucket and never escalates the exit code.
+
+### Breaking changes
+- The bundled "default rule set" and programmatic tool pinning of the beta are gone. Behaviour is driven by the smell catalogue plus the consumer's own tool configs; `knip` is no longer version-pinned, so the consumer's installed version determines available issue types.
+- The `rules` config field is **deprecated in favour of `smells`** (#21). `rules` is still accepted and folded in (with `smells` winning on conflict), but a config using it now emits a deprecation warning on stderr. Hard removal of `rules` is scheduled for a release after 0.2.0.

habit_hooks-1.0.0/CLAUDE.md

@@ -0,0 +1,165 @@
+# habit-hooks notes
+
+## Architecture
+
+### Plugins are installed packages discovered via entry points (human-requested by Ivett)
+
+The core finds plugins through the `habit_hooks.plugins` entry-point group, NOT
+by walking a sibling `plugins/` directory. Each plugin is a separately
+installable dist `habit-hooks-<name>` whose import package `habit_hooks_<name>`
+ships its `config.toml`/`sensors/`/`guides/`/helper scripts/phar as package data
+(importlib.resources-accessible). `resolve.installed_plugin_dirs()` maps plugin
+name -> package-data dir via `importlib.metadata.entry_points` +
+`importlib.resources.files`. The override chain is
+`.habit-hooks/<plugin>/<file>` (project) -> `<plugin package data>/<file>`
+(default). A configured plugin that is neither overridden under `.habit-hooks/`
+nor installed raises a clear error naming `pip install habit-hooks-<name>`
+(`Resolver.require_plugin`) — that is the bug-1 root-cause guard.
+
+The repo is a uv workspace (`[tool.uv.workspace] members = ["plugins/*"]`); the
+four in-repo plugins live under `plugins/<name>/src/habit_hooks_<name>/` and are
+installed editable by `uv sync` for dev. Keeping them in-repo is only a dev
+convenience — they do not need to live here. `tests/test_installed_wheel_smoke.py`
+builds + installs the core + generic wheels into a throwaway venv and asserts a
+real finding comes out; it is the gate that catches "installed runs can't locate
+plugins". `${dir}` in a sensor command resolves to the plugin's package-data dir,
+so helper-script paths (`${dir}/line-count.py`, `${dir}/../.jscpd.json`) keep
+working once the layout is preserved under the import package.
+
+### Sensor `args` live in the sensor's own toml, not the plugin `config.toml` (agent decision)
+
+A sensor's default CLI args (e.g. line-count's `--max 200`) live as `args = [...]`
+in `sensors/<name>.toml` and expand into the command via `${args}`. They cannot go
+in the plugin `config.toml` because `sensors = [...]` (the ordered list) and a
+`[sensors.<name>]` table collide as the same TOML key. A project replaces them
+wholesale via `.habit-hooks/config.toml` `[sensors.<name>] args = [...]`
+(replace-on-override — `SensorOverride.args`, threaded in `sensors._sensor_args`).
+
+### jscpd resolves a config's relative `path` against the config file, not cwd (agent decision)
+
+When `jscpd --config <abs path>` loads `.jscpd.json`, its `path: ["src"]` resolves
+relative to the config file's directory, so a plugin-shipped config scans nothing
+in the consumer repo. `plugins/generic/sensors/jscpd.py` therefore reads `path`
+out of the config and passes those as positional args (resolved against cwd),
+keeping the config the single source for threshold/ignore/minLines/minTokens.
+
+## Gotchas
+
+### knip runs a gated second pass in production mode (issue #59)
+
+`knipWrap` runs knip twice when — and only when — the consumer's knip
+config marks production patterns with a trailing `!` (detected by
+`knipConfigMarksProduction` in `knip-resolve.ts`). The default pass is
+authoritative for everything (incl. unused devDependencies); the
+`--production` pass contributes only dead-code findings
+(`PRODUCTION_PASS_SOURCES` in `knip-merge.ts`), merged + deduped. This
+catches code reached only by tests without losing devDep detection.
+Gotchas: `--production` analyses NOTHING unless `!` is on BOTH `entry`
+and `project` (a no-`!` config under `--production` silently reports
+zero — so we never pass it there). Test files must be listed as
+unmarked (non-production) `entry`, else knip 5 + a vitest config falsely
+reports them as unused files. The merge intentionally keeps `knip:files`
+from the production pass, so a wholly test-only production file can
+surface as an unused file — that's the feature, not a bug.
+
+### JSDoc nodes are not MultiLineCommentTrivia in ts-morph
+
+`/** ... */` blocks are `SyntaxKind.JSDoc` (321) when attached to a
+declaration, NOT `MultiLineCommentTrivia`. To find them, query both. See
+`src/checks/comment-check.ts`.
+
+### knip's `exports` field omits the bin path
+
+`knip` exports only `.` and `./session`, so
+`require.resolve('knip/bin/knip.js')` fails. The bundled-fallback resolver
+in `src/checks/knip-wrap.ts` (`bundledKnipBin`) resolves `'knip'` (main
+entry) and navigates up to `../bin/knip.js` instead. Consumer-detected
+knip is found via `detectTool`, which walks `package.json#bin.knip` and
+does not hit this hazard.
+
+### knip needs `package.json` in cwd
+
+Running knip in a directory without `package.json` exits 2 with a help
+message. `knipWrap` skips silently when no `package.json` is present —
+the user's project always has one, but our internal test temp dirs
+often don't.
+
+### knip 5 vs 6 — issue type drift
+
+We no longer pin knip; the consumer's installed version drives what
+fires. v5 emits `classMembers`; v6 dropped that key and surfaces unused
+exports via `files` / `exports` / `dependencies` instead. We ship
+coaching prompts for all four so either version is covered. If a future
+knip introduces a new top-level issue key, the wrap surfaces it as an
+uncoached violation (see `unknownKeysForIssue` in
+`src/checks/knip-wrap.ts`); add a prompt to coach it.
+
+### comment-check file discovery doesn't honour project ignores
+
+`runner.discoverFiles` uses fast-glob with a hardcoded ignore set
+(`node_modules`, `dist`, `coverage`). Only `comment-check` consumes that
+list directly — the eslint, knip, and jscpd wraps delegate discovery to
+their respective tools. Fixtures under `tests/fixtures/**` therefore get
+swept by comment-check when you run `node dist/cli.js` against the repo
+root, which is why a smoke run on our own source shows comment
+violations from inside fixtures.
+
+### Bumping pnpm 10 → 11 needs Corepack, not auto-switch
+
+pnpm 11 split its launcher: the main `pnpm` npm package owns
+`dist/pnpm.mjs`, while `@pnpm/macos-arm64` (and siblings) ship only the
+native loader. pnpm 10's `packageManager` auto-switch fetches only the
+platform package, producing a binary missing its JS bootstrap —
+`Cannot find module .../dist/pnpm.mjs`. Bootstrap pnpm 11 via Corepack
+(`corepack prepare pnpm@<v> --activate`) or the official installer
+instead. The standalone shim at `~/Library/pnpm/pnpm` is from the old
+installer; once Corepack is on PATH, remove the shim so it stops
+shadowing it.
+
+### Wrap shell-out semantics — failures sit in `result.warnings`
+
+`src/wrap/shell.ts` never throws on spawn/timeout failure. A spawn
+failure surfaces as `exitCode === -1` with the cause in `warnings`; a
+non-zero exit from the tool itself comes back with the real `exitCode`
+and an empty `warnings`. The helpers `isSpawnFailure` and
+`spawnFailureWarning` in `src/wrap/notices.ts` separate the two so a
+crashed tool produces a stderr notice (and zero violations) instead of
+silently swallowing the run.
+
+### jscpd `-n` (noSymlinks) is baked in
+
+`jscpdWrap` always passes `-n`. A consumer with intentionally symlinked
+source directories (monorepo `src/shared -> ../shared-lib`) silently
+will not get duplication detection on the linked paths. Surface this if
+a user reports missing jscpd hits on a symlinked tree.
+
+### Bundled habit-hooks ESLint vs project-local ESLint disagree on type-position param names
+
+Our bundled config flags an unused parameter in a type-only function
+signature (e.g. `resolve: (_result: ShellResult) => void`); the
+project's flat config does not. Underscoring the param satisfies both.
+This bit us during Phase 1/2 — if a wrap introduces a new callback type
+and the build trips on `no-unused-vars` for a positional name, prefix
+with `_`.
+
+### Tool config filename lists live in `src/detect/tool.ts`
+
+`TOOL_CONFIG_FILENAMES` and `TOOL_PACKAGE_JSON_KEYS` are the single
+source for tool config discovery. When you add a new tool, a new config
+filename, or a new `package.json` key (e.g. `eslint.config.cjs`,
+`knip.jsonc`), update those tables only — `detectTool` and every
+caller flows through them. Individual wraps may keep their own narrower
+lists for internal "has-config" checks, but those should mirror the
+canonical set.
+
+### A sensor named `ruff.toml` collides with ruff's config discovery
+
+`plugins/python/sensors/ruff.toml` is a sensor spec (`command = ...`),
+but ruff treats any file literally named `ruff.toml` as its own config.
+A `ruff check` whose upward config-discovery walk passes through
+`plugins/python/sensors/` hard-fails with `unknown field 'command'`.
+Harmless in normal consumer operation — the file lives inside the
+habit-hooks package, off the consumer's discovery path — but a future
+dogfooding ruff run from inside that tree will be mystifying. Point ruff
+at an explicit `--config` (the repo-root `ruff.toml`, gitignored as
+`/ruff.toml`) if you hit this.

habit_hooks-1.0.0/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ivett Ördög
+
+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.

habit_hooks-1.0.0/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: habit-hooks
+Version: 1.0.0
+Summary: Turn best-practice coding advice into AI habits — structural code-smell coaching for AI agents
+License-File: LICENSE.md
+Requires-Python: >=3.11
+Requires-Dist: habit-hooks-generic~=1.0
+Requires-Dist: jinja2>=3
+Requires-Dist: pathspec>=0.12
+Requires-Dist: pydantic>=2
+Provides-Extra: all
+Requires-Dist: habit-hooks-php~=1.0; extra == 'all'
+Requires-Dist: habit-hooks-python~=1.0; extra == 'all'
+Requires-Dist: habit-hooks-typescript~=1.0; extra == 'all'
+Provides-Extra: php
+Requires-Dist: habit-hooks-php~=1.0; extra == 'php'
+Provides-Extra: python
+Requires-Dist: habit-hooks-python~=1.0; extra == 'python'
+Provides-Extra: typescript
+Requires-Dist: habit-hooks-typescript~=1.0; extra == 'typescript'