where-are-we 0.1.0__tar.gz

where_are_we-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,44 @@
+name: ci
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  smoke:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python: ["3.10", "3.12"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python }}
+      - name: install
+        run: pip install . pytest
+      - name: tests
+        run: pytest tests -q
+
+      - name: map itself
+        run: where-are-we --repo . --out /tmp/map && test -s /tmp/map/framework_map_brief.md
+      - name: map a polyglot fixture
+        run: |
+          mkdir -p /tmp/fx/steps /tmp/fx/migrations
+          printf 'from behave import step\n@step("a user exists")\ndef f(c):\n    pass\n' > /tmp/fx/steps/a.py
+          printf 'Given("a logged in user", async function () {});\n' > /tmp/fx/steps.ts
+          printf 'func TestFoo(t *testing.T) {}\n' > /tmp/fx/main_test.go
+          printf 'CREATE TABLE users (id int, email text);\n' > /tmp/fx/migrations/V1__init.sql
+          where-are-we --repo /tmp/fx --out /tmp/fxmap
+          grep -q "cucumber-js" /tmp/fxmap/framework_map_brief.md
+          grep -q "users" /tmp/fxmap/framework_map_brief.md
+      - name: manifest and hooks
+        run: |
+          where-are-we --repo /tmp/fx --init && test -f /tmp/fx/.framework-map.json
+          git -C /tmp/fx init -q && where-are-we --repo /tmp/fx --install-hook git
+          test -x /tmp/fx/.git/hooks/post-checkout
+      - name: idempotent
+        run: |
+          where-are-we --repo . --out /tmp/map | tee /tmp/first
+          where-are-we --repo . --out /tmp/map | grep -q "unchanged since it was built"

where_are_we-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,19 @@
+name: release
+
+on:
+  push:
+    tags: ["v*"]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install build
+      - run: python -m build
+      - uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          password: ${{ secrets.PYPI_API_TOKEN }}

where_are_we-0.1.0/.gitignore

@@ -0,0 +1,6 @@
+__pycache__/
+*.pyc
+dist/
+build/
+*.egg-info/
+.venv/

where_are_we-0.1.0/CHANGELOG.md

@@ -0,0 +1,22 @@
+# Changelog
+
+## 0.1.0
+
+First release.
+
+- Indexes any codebase into `framework_map.{json,md}` and a brief for a prompt:
+  languages, entry points, HTTP routes, data model, public surface, import and
+  cross-file call graphs, queues, gRPC, schedules, Kubernetes, Terraform, cache
+  keys, permissions, observability, error types, CLI, frontend, contracts
+  (OpenAPI, GraphQL, migrations, mocks, flags, i18n), ADRs, coverage, hotspots,
+  licenses, git history, blame owners, deprecations and documentation drift.
+- Test suites across behave, pytest, jest, playwright, cypress, robot, JUnit,
+  TestNG, Cucumber in Java, Kotlin, Scala, TypeScript, JavaScript and Ruby,
+  rspec, go test, xUnit, NUnit, SpecFlow, PHPUnit, Behat, Rust, XCTest, karate,
+  gauge, k6 — plus the suite's own state: overlapping phrases, unused steps,
+  dead page-object methods, admitted debts, quarantine and past-run timings.
+- `--init` writes a manifest a repository can correct; what it states wins.
+- `--install-hook git|agent`, `--agent-file`, `--only`, `--skip`, `--max-lines`,
+  `--diff`, `--force`, `.wawe-ignore`.
+- Rebuilds only when the tree has moved; JSON contract versioned as
+  `where-are-we/1` and documented in `SCHEMA.md`.

where_are_we-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 BoberIT
+
+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.

where_are_we-0.1.0/PKG-INFO

@@ -0,0 +1,231 @@
+Metadata-Version: 2.5
+Name: where-are-we
+Version: 0.1.0
+Summary: Answer 'where are we?' for a codebase: index a test suite and the product it tests into a map an agent can read instead of grepping.
+Author: BoberIT
+License: MIT
+License-File: LICENSE
+Keywords: agents,behave,codebase-map,cucumber,pytest,testing
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+<div align="center">
+
+# where-are-we
+
+**The first question in an unfamiliar repository — answered in seconds, without a model.**
+
+*Any codebase. Any language. Any agent.*
+
+[![License: MIT](https://img.shields.io/badge/license-MIT-black.svg)](LICENSE)
+[![Python](https://img.shields.io/badge/python-3.10%2B-black.svg)](https://www.python.org)
+[![Frameworks](https://img.shields.io/badge/frameworks-20%2B-black.svg)](#frameworks)
+[![No dependencies](https://img.shields.io/badge/dependencies-none-black.svg)](pyproject.toml)
+
+</div>
+
+---
+
+An agent opening a repository it has never seen spends its first forty tool
+calls on the same questions. Where do the tests live. What may a step call. How
+is a scenario launched. Which environment variables must be set. What does the
+product actually expose.
+
+At roughly a minute per turn that is half an hour, in every session, for answers
+that are identical every time and derivable without a model.
+
+`where-are-we` derives them by walking the tree, and writes them where the agent
+will read them.
+
+```bash
+pip install git+https://github.com/ngavrish/where-are-we
+
+where-are-we --repo ~/work/my-suite --product ~/work/my-app/src --out /tmp/map
+```
+
+```
+framework map: 66 step modules, 1446 steps, 182 features, 1889 scenarios -> /tmp/map/framework_map.md
+```
+
+## What you get
+
+| file | what it is | typical size |
+|---|---|---|
+| `framework_map_brief.md` | the digest to put in a prompt | ~40 KB |
+| `framework_map.md` | the full map: every step phrase, every scenario with its line number | ~135 KB |
+| `framework_map.json` | the same as data, for tooling | — |
+
+Or straight into the file your harness already reads:
+
+```bash
+where-are-we --repo . --agent-file AGENTS.md      # also CLAUDE.md, .cursorrules, …
+```
+
+The map is written between markers. Whatever else lives in that file survives.
+
+## What it finds
+
+Whatever the repository is. A service, a library, a monorepo, a test suite — it
+is read the same way: what it is made of, where it starts, what it serves, what
+it exposes, and how its parts depend on each other.
+
+
+<table>
+<tr><td width="50%" valign="top">
+
+**Any codebase**
+
+- languages, by file count
+- where execution starts: entry points, `make` targets, npm scripts, container `CMD`
+- the HTTP routes it serves — Flask, FastAPI, Django, Express, Go, Spring, Rails
+- its data model — SQLAlchemy, Django, Prisma, TypeORM
+- the public surface of each module
+- how the top-level packages depend on each other
+- monorepo layout, where there is one
+- queues, topics and subjects — Kafka, RabbitMQ, SQS, pub/sub
+- gRPC services and their methods, from `.proto`
+- scheduled work — cron, Celery beat, Airflow, Kubernetes CronJobs
+- Kubernetes and Helm manifests, and Terraform resources
+- cache keys, permissions and roles
+- metrics, spans and log fields
+- the error types the code defines
+- command-line commands — click, argparse, cobra
+- frontend components, stores and hooks
+- architecture decision records, coverage reports, largest files, declared licenses
+
+**Shape of a test suite**
+
+- how the suite is layered, and where each layer lives
+- how a scenario is launched, from the runner scripts' own usage headers
+- what a step may call — public methods, with signatures
+- which step modules and page objects serve each feature
+- what each step actually calls
+
+**Facts you would otherwise grep for**
+
+- every scenario, with its line number
+- every environment variable, and the file that sets it
+- locator constants, timeouts, budgets, retries
+- module constants and helpers
+- hooks, and what they do
+- fixtures, test data, coverage documents
+- code owners, per-directory READMEs
+
+</td><td width="50%" valign="top">
+
+**The product under test**
+
+- routes, storage keys, API paths
+- every `data-testid`, and which component owns it
+- interface strings an assertion can match
+
+**Contracts**
+
+- OpenAPI parsed to method and path
+- GraphQL to its types
+- migrations to the tables and columns they create
+- mock servers, feature flags, locale keys
+- pinned image tags, secret paths (paths only)
+
+**The state of the suite itself**
+
+- step phrases that overlap — so a new one is not written when one exists
+- phrases no feature uses
+- page-object methods nothing calls
+- the TODO and FIXME the code already admits to
+- git history, and which ticket touched what
+- quarantined scenarios, and the slow ones
+
+</td></tr>
+</table>
+
+## Frameworks
+
+behave · pytest · jest · playwright · cypress · robot · JUnit · TestNG ·
+Cucumber-JVM (Java · Kotlin · Scala) · cucumber-js (TypeScript · JavaScript) ·
+cucumber-ruby · rspec · go test · xUnit · NUnit · SpecFlow · PHPUnit · Behat ·
+Rust · XCTest · karate · gauge · k6 · gatling
+
+Detection is by shape, not by directory name: a page object is a class that owns
+selectors — wherever it lives, whatever the team calls it. Run it on a
+repository before you know what is in it.
+
+## When the repository knows better
+
+Autodetection gets the shape right and the vocabulary wrong. A repository states
+its own, and what it states wins:
+
+```bash
+where-are-we --repo . --init      # writes a starter manifest from what was detected
+```
+
+```json
+{
+  "name": "billing-e2e",
+  "purpose": "End-to-end tests for the billing portal.",
+  "layers": {
+    "steps": "steps/*.py — steps own no selectors, they call page objects"
+  },
+  "product_src": ["../billing-web/src"],
+  "conventions": ["After a fix, re-run only what failed."]
+}
+```
+
+`.framework-map.json` at the root, or the same block fenced as
+` ```framework-map ` inside `README.md`.
+
+Directories can explain themselves too:
+
+```bash
+wawe-readmes --repo .    # a README in every content directory that lacks one,
+                         # derived from what is in it, with one TODO line for a human
+```
+
+The map reads them back.
+
+## Keeping it current
+
+A map is worth rebuilding when the thing it describes has moved. The commit and
+the newest file in the tree are recorded with it, so running the command on
+every checkout costs a stat walk and nothing else. `--force` rebuilds regardless.
+
+```bash
+where-are-we --repo . --install-hook git     # post-checkout, post-merge, post-commit
+where-are-we --repo . --install-hook agent   # SessionStart, before the first turn
+```
+
+## Options
+
+```
+--repo PATH          the test repository to index
+--product PATH,…     source roots of the application under test
+--out DIR            where the three files land
+--agent-file FILE    also write the brief into AGENTS.md / CLAUDE.md / .cursorrules
+--rules PATH         a corpus of rules to list by name
+--runs-api URL       a runs database, to carry what earlier runs concluded
+--init               write a starter .framework-map.json
+--install-hook git|agent
+--force              rebuild even when nothing moved
+--only "routes,data model"   keep only these sections in the brief
+--skip "coverage,history"    drop these
+--max-lines N        cap the brief; the full map is untouched
+--diff               what changed since the map already in --out
+--quiet              no summary line
+```
+
+## Why it exists
+
+It was built for an agentic QA pipeline where seven branches ran at once and
+each one opened the same way: forty greps to find where the steps live, which
+page object owns the portal, how the driver is built, what `environment.py`
+does. Identical in every branch, identical every run, and derivable without a
+model — three runs died at their deadline with the branches still reading.
+
+Nothing about it turned out to be specific to that pipeline, or to that agent,
+or to Python. So it lives here.
+
+## License
+
+MIT

where_are_we-0.1.0/README.md

@@ -0,0 +1,218 @@
+<div align="center">
+
+# where-are-we
+
+**The first question in an unfamiliar repository — answered in seconds, without a model.**
+
+*Any codebase. Any language. Any agent.*
+
+[![License: MIT](https://img.shields.io/badge/license-MIT-black.svg)](LICENSE)
+[![Python](https://img.shields.io/badge/python-3.10%2B-black.svg)](https://www.python.org)
+[![Frameworks](https://img.shields.io/badge/frameworks-20%2B-black.svg)](#frameworks)
+[![No dependencies](https://img.shields.io/badge/dependencies-none-black.svg)](pyproject.toml)
+
+</div>
+
+---
+
+An agent opening a repository it has never seen spends its first forty tool
+calls on the same questions. Where do the tests live. What may a step call. How
+is a scenario launched. Which environment variables must be set. What does the
+product actually expose.
+
+At roughly a minute per turn that is half an hour, in every session, for answers
+that are identical every time and derivable without a model.
+
+`where-are-we` derives them by walking the tree, and writes them where the agent
+will read them.
+
+```bash
+pip install git+https://github.com/ngavrish/where-are-we
+
+where-are-we --repo ~/work/my-suite --product ~/work/my-app/src --out /tmp/map
+```
+
+```
+framework map: 66 step modules, 1446 steps, 182 features, 1889 scenarios -> /tmp/map/framework_map.md
+```
+
+## What you get
+
+| file | what it is | typical size |
+|---|---|---|
+| `framework_map_brief.md` | the digest to put in a prompt | ~40 KB |
+| `framework_map.md` | the full map: every step phrase, every scenario with its line number | ~135 KB |
+| `framework_map.json` | the same as data, for tooling | — |
+
+Or straight into the file your harness already reads:
+
+```bash
+where-are-we --repo . --agent-file AGENTS.md      # also CLAUDE.md, .cursorrules, …
+```
+
+The map is written between markers. Whatever else lives in that file survives.
+
+## What it finds
+
+Whatever the repository is. A service, a library, a monorepo, a test suite — it
+is read the same way: what it is made of, where it starts, what it serves, what
+it exposes, and how its parts depend on each other.
+
+
+<table>
+<tr><td width="50%" valign="top">
+
+**Any codebase**
+
+- languages, by file count
+- where execution starts: entry points, `make` targets, npm scripts, container `CMD`
+- the HTTP routes it serves — Flask, FastAPI, Django, Express, Go, Spring, Rails
+- its data model — SQLAlchemy, Django, Prisma, TypeORM
+- the public surface of each module
+- how the top-level packages depend on each other
+- monorepo layout, where there is one
+- queues, topics and subjects — Kafka, RabbitMQ, SQS, pub/sub
+- gRPC services and their methods, from `.proto`
+- scheduled work — cron, Celery beat, Airflow, Kubernetes CronJobs
+- Kubernetes and Helm manifests, and Terraform resources
+- cache keys, permissions and roles
+- metrics, spans and log fields
+- the error types the code defines
+- command-line commands — click, argparse, cobra
+- frontend components, stores and hooks
+- architecture decision records, coverage reports, largest files, declared licenses
+
+**Shape of a test suite**
+
+- how the suite is layered, and where each layer lives
+- how a scenario is launched, from the runner scripts' own usage headers
+- what a step may call — public methods, with signatures
+- which step modules and page objects serve each feature
+- what each step actually calls
+
+**Facts you would otherwise grep for**
+
+- every scenario, with its line number
+- every environment variable, and the file that sets it
+- locator constants, timeouts, budgets, retries
+- module constants and helpers
+- hooks, and what they do
+- fixtures, test data, coverage documents
+- code owners, per-directory READMEs
+
+</td><td width="50%" valign="top">
+
+**The product under test**
+
+- routes, storage keys, API paths
+- every `data-testid`, and which component owns it
+- interface strings an assertion can match
+
+**Contracts**
+
+- OpenAPI parsed to method and path
+- GraphQL to its types
+- migrations to the tables and columns they create
+- mock servers, feature flags, locale keys
+- pinned image tags, secret paths (paths only)
+
+**The state of the suite itself**
+
+- step phrases that overlap — so a new one is not written when one exists
+- phrases no feature uses
+- page-object methods nothing calls
+- the TODO and FIXME the code already admits to
+- git history, and which ticket touched what
+- quarantined scenarios, and the slow ones
+
+</td></tr>
+</table>
+
+## Frameworks
+
+behave · pytest · jest · playwright · cypress · robot · JUnit · TestNG ·
+Cucumber-JVM (Java · Kotlin · Scala) · cucumber-js (TypeScript · JavaScript) ·
+cucumber-ruby · rspec · go test · xUnit · NUnit · SpecFlow · PHPUnit · Behat ·
+Rust · XCTest · karate · gauge · k6 · gatling
+
+Detection is by shape, not by directory name: a page object is a class that owns
+selectors — wherever it lives, whatever the team calls it. Run it on a
+repository before you know what is in it.
+
+## When the repository knows better
+
+Autodetection gets the shape right and the vocabulary wrong. A repository states
+its own, and what it states wins:
+
+```bash
+where-are-we --repo . --init      # writes a starter manifest from what was detected
+```
+
+```json
+{
+  "name": "billing-e2e",
+  "purpose": "End-to-end tests for the billing portal.",
+  "layers": {
+    "steps": "steps/*.py — steps own no selectors, they call page objects"
+  },
+  "product_src": ["../billing-web/src"],
+  "conventions": ["After a fix, re-run only what failed."]
+}
+```
+
+`.framework-map.json` at the root, or the same block fenced as
+` ```framework-map ` inside `README.md`.
+
+Directories can explain themselves too:
+
+```bash
+wawe-readmes --repo .    # a README in every content directory that lacks one,
+                         # derived from what is in it, with one TODO line for a human
+```
+
+The map reads them back.
+
+## Keeping it current
+
+A map is worth rebuilding when the thing it describes has moved. The commit and
+the newest file in the tree are recorded with it, so running the command on
+every checkout costs a stat walk and nothing else. `--force` rebuilds regardless.
+
+```bash
+where-are-we --repo . --install-hook git     # post-checkout, post-merge, post-commit
+where-are-we --repo . --install-hook agent   # SessionStart, before the first turn
+```
+
+## Options
+
+```
+--repo PATH          the test repository to index
+--product PATH,…     source roots of the application under test
+--out DIR            where the three files land
+--agent-file FILE    also write the brief into AGENTS.md / CLAUDE.md / .cursorrules
+--rules PATH         a corpus of rules to list by name
+--runs-api URL       a runs database, to carry what earlier runs concluded
+--init               write a starter .framework-map.json
+--install-hook git|agent
+--force              rebuild even when nothing moved
+--only "routes,data model"   keep only these sections in the brief
+--skip "coverage,history"    drop these
+--max-lines N        cap the brief; the full map is untouched
+--diff               what changed since the map already in --out
+--quiet              no summary line
+```
+
+## Why it exists
+
+It was built for an agentic QA pipeline where seven branches ran at once and
+each one opened the same way: forty greps to find where the steps live, which
+page object owns the portal, how the driver is built, what `environment.py`
+does. Identical in every branch, identical every run, and derivable without a
+model — three runs died at their deadline with the branches still reading.
+
+Nothing about it turned out to be specific to that pipeline, or to that agent,
+or to Python. So it lives here.
+
+## License
+
+MIT

where_are_we-0.1.0/SCHEMA.md

@@ -0,0 +1,52 @@
+# `framework_map.json` — schema `where-are-we/1`
+
+Stable contract. Sections may be added within a major version; a section that
+exists keeps its shape. `schema` names the version; `fingerprint` is what the map
+was built from (commit and newest mtime) and is how staleness is decided.
+
+| key | shape | what it is |
+|---|---|---|
+| `schema` | string | `where-are-we/<major>` |
+| `repo` | string | absolute path indexed |
+| `fingerprint` | string | `<commit>:<newest mtime>` |
+| `stated` | object | what `.framework-map.json` declared, verbatim |
+| `languages` | {lang: count} | files per language |
+| `entry` | {what: [lines]} | entry points, make targets, npm scripts, container CMD |
+| `exports` | {file: [names]} | public surface per module |
+| `routes_served` | [string] | HTTP routes the code serves |
+| `models` | {name: [fields]} | ORM models and their fields |
+| `import_graph` | {package: [packages]} | dependencies between top-level packages |
+| `call_graph_files` | {file:func: [callees]} | cross-file calls |
+| `data_flow` | {file: {paths, tables}} | endpoints and tables co-located |
+| `messaging` | {file: [topics]} | queues, topics, subjects |
+| `grpc` | {service: [methods]} | from `.proto` |
+| `schedules` | {file: [expressions]} | cron, beat, DAGs, CronJobs |
+| `kubernetes` | {file: {kinds, names}} | manifests |
+| `iac` | {file: [[type, name]]} | Terraform resources |
+| `cache_keys` | [string] | cache keys the code uses |
+| `permissions` | {file: [names]} | roles, scopes, guards |
+| `observability` | {metrics, spans, log_fields} | names emitted |
+| `error_types` | {class: file} | error and exception types |
+| `cli_commands` | {file: [commands]} | click, argparse, cobra |
+| `frontend` | {components, stores, hooks} | UI structure |
+| `contracts` | {openapi, graphql, migrations, mocks, feature_flags, i18n, images, secret_paths} | files |
+| `contract_details` | {endpoints, graphql, migration_tables, i18n_keys, flags} | parsed contents |
+| `steps` | {file: [phrases]} | step definitions |
+| `features` | {file: {scenarios: [{line, name}], tags}} | feature files |
+| `page_objects`, `drivers`, `scripts` | [paths] | test layers |
+| `public_api` | {file: [signatures]} | what a step may call |
+| `feature_links` | {feature: {step_modules, page_objects}} | traceability |
+| `near_duplicates` | [{a, a_in, b, b_in, similarity}] | overlapping phrases |
+| `unused_steps`, `unused_api` | {file: [names]} | dead weight |
+| `debts` | {file: [lines]} | TODO, FIXME, skip |
+| `git_history` | {file: [commits]} | most-changed files |
+| `ticket_links` | {ticket: {subject, files}} | what a ticket touched |
+| `blame_owners` | {file: [people]} | who has been touching what |
+| `coverage_by_file` | {file: percent} | from coverage reports |
+| `deprecations`, `api_versions`, `doc_drift` | see README | decay signals |
+| `scenario_history`, `slow_steps` | from junit | what past runs measured |
+| `dir_readmes` | {dir: {path, summary, headings}} | directories explaining themselves |
+| `counts` | {step_modules, steps, features, scenarios} | totals |
+
+Everything is derived; nothing is inferred by a model. An absent section means
+the repository has none of that, not that the tool failed.

where_are_we-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[project]
+name = "where-are-we"
+version = "0.1.0"
+description = "Answer 'where are we?' for a codebase: index a test suite and the product it tests into a map an agent can read instead of grepping."
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+authors = [{name = "BoberIT"}]
+keywords = ["testing", "agents", "codebase-map", "behave", "pytest", "cucumber"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Topic :: Software Development :: Testing",
+]
+dependencies = []
+
+[project.scripts]
+where-are-we = "where_are_we.mapper:main"
+wawe-readmes = "where_are_we.readmes:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/where_are_we"]

where_are_we-0.1.0/src/where_are_we/__init__.py

@@ -0,0 +1,4 @@
+from .mapper import build, brief, digest, init_manifest, main
+
+__all__ = ["build", "brief", "digest", "init_manifest", "main"]
+__version__ = "0.1.0"