codeabc 0.1.0__py3-none-any.whl

codeabc-0.1.0.dist-info/METADATA

@@ -0,0 +1,283 @@
+Metadata-Version: 2.4
+Name: codeabc
+Version: 0.1.0
+Summary: AI-powered code reader for non-programmers
+Author-email: Yufeng He <40085740+he-yufeng@users.noreply.github.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai,code-reader,education,non-programmer
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: End Users/Desktop
+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 :: Education
+Classifier: Topic :: Software Development :: Documentation
+Requires-Python: >=3.10
+Requires-Dist: aiofiles>=24.0.0
+Requires-Dist: aiosqlite>=0.20.0
+Requires-Dist: fastapi>=0.115.0
+Requires-Dist: litellm>=1.40.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: python-multipart>=0.0.9
+Requires-Dist: uvicorn[standard]>=0.30.0
+Provides-Extra: dev
+Requires-Dist: httpx; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-asyncio; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Description-Content-Type: text/markdown
+
+<div align="center">
+
+<img src="docs/banner.png" alt="CodeABC — read code without learning to code" width="100%">
+
+[![Python](https://img.shields.io/badge/python-3.10+-blue)](https://python.org)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green)](LICENSE)
+[![CI](https://github.com/he-yufeng/CodeABC/actions/workflows/ci.yml/badge.svg)](https://github.com/he-yufeng/CodeABC/actions)
+
+[**Quick Start**](#run-it) · [**How It Works**](#how-it-works) · [**Features**](#features) · [中文](README_CN.md)
+
+</div>
+
+**Read code without learning to code.** An AI-powered code reader built for non-programmers.
+
+Cursor and VS Code are Swiss army knives for developers. CodeABC is a magnifying glass for everyone else -- it lets you read code like reading an article, and annotate code like annotating a document.
+
+## The Problem
+
+More and more non-programmers need to deal with code: grad students running Python data analysis scripts, product managers reviewing what developers built, founders evaluating outsourced code quality. But every existing tool assumes you already know how to code.
+
+**AI can already explain code perfectly.** What's missing is a product that wraps this capability in a UX designed for people who don't code.
+
+## How It Works
+
+![CodeABC architecture](docs/architecture.png)
+
+Drop in a folder or paste a GitHub link. CodeABC scans the project (skipping build output, caches, and secret-shaped files), builds **instant deterministic maps that need no API key** — a reading map, core-module ranking, test-coverage view, and more — then layers AI explanations on top: a plain-language project manual, line-by-line hover annotations, and a Q&A box. Everything shows up in a bilingual browser UI.
+
+## Features
+
+### Project Overview
+
+Drop in a project folder or paste a GitHub link. CodeABC scans the files and generates a plain-language "project manual":
+
+- **What is this?** One-sentence summary anyone can understand
+- **File guide** Every file explained in plain language, sorted by importance
+- **Reading map** A deterministic "start here, then read this" path appears before the AI call
+- **How to run it** Step-by-step instructions, no jargon
+- **Quick tips** "If you just want to change X, go to file Y"
+
+### Hover Annotations
+
+Click any file to view it with AI-generated annotations. Hover over any line to see a plain-language explanation of what it does. No programming jargon -- uses everyday analogies to explain concepts.
+
+- Fine-grained: annotations cover every 1-3 lines, not just blocks
+- Context-aware: explains _why_ a number is 0.05 or a timeout is 3600
+- Cached: annotations are stored locally so repeat visits are instant
+
+### Terminology Dictionary
+
+Every file view lists the programming terms that actually appear in that file -- `async`, `decorator`, `closure`, `middleware`, `regex`, and dozens more. Hover a term to see a plain-language explanation that leans on everyday analogies. It is computed deterministically (no LLM, no API key), so it is instant and always available.
+
+### Natural-Language Editing
+
+Describe a change in plain words -- "把茅台换成比亚迪", "change the timeout from 3600 to 600" -- and CodeABC returns a suggested rewrite of the selected snippet, touching only what you asked for. It never writes to your files; the result is yours to review and copy.
+
+### Q&A Mode
+
+Select any snippet in a file (or just leave it unselected for the whole file) and ask a question in plain language -- "what does this do?", "why is this number here?". CodeABC answers in the same patient, jargon-light voice, grounded only in the code you pointed at. Answers are cached, so asking the same thing again is free.
+
+### Bilingual UI (中文 / English)
+
+The whole interface switches between Chinese and English with one toggle in the header. Your choice is remembered, and the first visit follows your browser language. (LLM-generated content like the manual and annotations follows the prompt language; the UI chrome is fully translated.)
+
+### Cleaner Project Scans
+
+CodeABC skips build outputs, package caches, minified bundles, generated frontend chunks, and paths ignored by the repository's `.gitignore` before sending files to the LLM. It also leaves out secret-shaped files such as real `.env` files, credential JSON files, API key notes, and private keys while still allowing safe examples like `.env.example`. That keeps the project manual focused on source code instead of `dist/`, `node_modules`, local scratch files, one-line JavaScript bundles, or private credentials.
+
+### Start Reading Immediately
+
+Before an LLM response is ready, CodeABC builds a deterministic reading map from README files, likely entry points, package manifests, core source directories, and tests. It gives newcomers a useful first route even when no API key is configured.
+
+### Core Modules at a Glance
+
+CodeABC builds a small import graph from the scanned files and ranks them by fan-in: how many other files import each one. The most-imported files are usually where the real logic lives (shared utilities, data models, core services), so they surface next to the reading map as "core modules", each tagged with the number of files that depend on it. It resolves Python imports (including relative and package imports) and JavaScript/TypeScript imports (relative paths with extension and index resolution), and ignores third-party and standard-library imports since they never point at a scanned file. Like the reading map, it runs without an LLM call, so it works with no API key configured.
+
+### Is the Code Tested?
+
+A blunt but useful question when you're sizing up code you didn't write — work you outsourced, say: does it actually have tests? CodeABC pairs each source file with the test files that exercise it, both by import and by the usual `test_scanner.py` / `scanner.test.ts` naming, then shows the share of files that are covered. More usefully, it ranks the *untested* files by how many other files depend on them: an untested file that half the project imports is exactly where a quiet regression spreads furthest, so it sits at the top of the "worth covering first" list with a plain-language note on why. A green progress bar gives the at-a-glance number; the list tells you where to look. Like the other maps it is deterministic and needs no API key.
+
+### What Does This File Even Do?
+
+`conftest.py`, `serializers.py`, `__init__.py`, `urls.py`, `Dockerfile` — to a developer these names are self-explanatory; to everyone else they are a wall. Open any file and CodeABC puts a one-line plain-language note at the top telling you what a file with that name usually is: that `__init__.py` just marks a folder as a package and is often empty, that `conftest.py` holds shared test setup and isn't project logic, that a `migrations/` file is an auto-generated database change you rarely need to read. It works off the filename alone, matching from the most specific convention down to a bare extension, so it is instant, needs no API key, and is right before the AI has said a word.
+
+### Does It Talk to the Outside World?
+
+Before trusting a script you didn't write, you usually want to know what it reaches out to: which AI provider, which cloud, which database, whether it moves money. CodeABC reads the imports and the hostnames in the code and lists the external services it depends on — OpenAI, AWS, a Postgres database, a Stripe payment call — each with a plain note on what that dependency means and why you might care. No API key required.
+
+### Where Do Errors Get Swallowed?
+
+The most dangerous line in a codebase is often the one that quietly hides a problem: a bare `except:` that catches everything, an empty `catch {}` that throws the error away, a failure that gets logged and then ignored. To a non-coder these are invisible; to a maintainer they are where bugs go to hide. CodeABC flags these silent-failure spots and explains, in everyday terms, why "the program kept going as if nothing happened" can be worse than crashing loudly.
+
+### Which Files Are Begging for Docs?
+
+Not every file needs a comment, but the ones that other files lean on heavily and that still have almost no explanation are the ones that cost a newcomer the most. CodeABC scores each file on how under-documented it is relative to how central it is, and surfaces the handful that would help the most if someone wrote a few sentences at the top. It is a reading aid as much as a writing one: these are usually the files worth understanding first.
+
+## Tech Stack
+
+| Layer | Choice | Why |
+|-------|--------|-----|
+| Frontend | React 19 + Vite + TailwindCSS 4 | Fast dev, no SSR needed for this app |
+| Code highlighting | Shiki | VS Code-quality syntax highlighting, zero runtime JS |
+| Tooltips | @floating-ui/react | Lightweight positioning for hover annotations |
+| State | Zustand | Minimal, performant state management |
+| Backend | FastAPI + uvicorn | Async Python, great for streaming LLM responses |
+| LLM | litellm | Multi-provider support (OpenAI, Claude, DeepSeek, Kimi, etc.) |
+| Cache | SQLite | Simple, no Redis needed for MVP |
+
+## Run It
+
+One command, no setup:
+
+```bash
+python run.py
+```
+
+On Windows you can just double-click `start.bat`; on macOS/Linux, run `./start.sh`. The first run builds the web interface and installs dependencies — after that it just starts. Everything is served from one place, and it opens in your browser for you once the server is ready — at http://127.0.0.1:8000, or the next free port if 8000 is already taken. Press Ctrl+C to stop.
+
+You need **Python 3.10+**, plus **Node.js 18+** for that first build. Installing [uv](https://docs.astral.sh/uv/) is optional and makes startup faster.
+
+Then click the gear icon in the top-right and paste an API key (or use the free tier — see [API Key](#api-key)). An [OpenRouter](https://openrouter.ai) key (`sk-or-...`) is the easiest: one key reaches every provider, and CodeABC recognises it automatically and picks a fast, inexpensive model for you. OpenAI, Anthropic, and DeepSeek keys work too. To force a specific model, set `CODEABC_MODEL` (e.g. `openrouter/anthropic/claude-haiku-4.5`).
+
+### Developing
+
+To run the backend and the Vite dev server separately with hot reload:
+
+```bash
+# backend (terminal 1)
+python3 -m venv .venv && source .venv/bin/activate
+pip install -e .
+export OPENAI_API_KEY=<OPENAI_API_KEY>   # or ANTHROPIC_API_KEY / OPENROUTER_API_KEY / ...
+uvicorn backend.app:app --reload
+
+# frontend (terminal 2)
+cd frontend
+npm install
+npm run dev
+```
+
+The dev UI runs at http://localhost:5173 and calls the backend on port 8000.
+
+### Desktop app (Tauri)
+
+The same UI ships as a native desktop window via [Tauri](https://tauri.app) — a small Rust shell around the web frontend, no Electron-sized bundle. It's self-contained: the app bundles the FastAPI backend as a sidecar and starts it automatically, so there's nothing to run by hand. You'll need the [Rust toolchain](https://www.rust-lang.org/tools/install) installed to build it.
+
+```bash
+# 1. package the backend into the sidecar binary (clean venv with just the
+#    project's deps + pyinstaller; a fat env produces a huge binary)
+pip install -e . pyinstaller
+python scripts/build_desktop_sidecar.py
+
+# 2. build the desktop app (bundles that sidecar)
+cd frontend
+npm install
+npm run tauri:build    # installer in src-tauri/target/release/bundle/
+```
+
+The release app spawns the backend on 127.0.0.1:8000 at launch and stops it on exit. For development, run the backend yourself (`uvicorn backend.app:app --reload`) and use the hot-reloading window — `npm run tauri:dev` doesn't start the sidecar:
+
+```bash
+npm run tauri:dev
+```
+
+### Using It
+
+1. **Local folder**: Drag a project folder into the upload zone, or click to select
+2. **GitHub repo**: Paste a GitHub URL like `https://github.com/user/repo` and click "Analyze"
+3. Browse the generated project overview
+4. Click any file to see it with hover annotations
+
+### API Key
+
+CodeABC supports two modes:
+
+- **Free mode** (default): Limited to 20 requests per day
+- **BYOK mode**: Click the gear icon in the top-right corner to enter your own API key for unlimited use. The key is stored only in your browser's localStorage.
+
+## Project Structure
+
+```
+CodeABC/
+├── backend/                 # Python FastAPI server
+│   ├── app.py               # Entry point, CORS, lifespan
+│   ├── desktop_server.py    # Sidecar launcher for the Tauri desktop build
+│   ├── models.py            # Pydantic data models
+│   ├── routers/
+│   │   ├── project.py       # Upload / GitHub clone / file endpoints
+│   │   └── analyze.py       # Overview + annotation generation
+│   ├── services/
+│   │   ├── scanner.py        # Project file scanner with smart filtering
+│   │   ├── importgraph.py    # Import-graph fan-in ranking (core-module detection)
+│   │   ├── github_clone.py   # Shallow clone with size limits
+│   │   ├── llm.py            # litellm wrapper (stream + non-stream)
+│   │   ├── cache.py          # SQLite cache + on-disk project library
+│   │   ├── codemap_export.py # Stitch every map into one offline codemap.md
+│   │   ├── report_export.py  # Self-contained offline HTML report
+│   │   └── …                 # + 28 deterministic, no-API-key analyzers (one per map)
+│   └── prompts/
+│       ├── overview.py      # Project overview prompt
+│       ├── annotate.py      # Line-by-line annotation prompt
+│       ├── qa.py            # Snippet / file Q&A prompt
+│       └── edit.py          # Natural-language editing prompt
+├── frontend/                # React + Vite + TailwindCSS
+│   └── src/
+│       ├── pages/           # Home, Overview, FileView
+│       ├── components/      # UploadZone, CodeViewer, AnnotationTooltip, ApiKeyModal
+│       ├── stores/          # Zustand state management
+│       └── lib/             # API client
+├── scripts/                 # Desktop sidecar build (PyInstaller)
+├── pyproject.toml
+└── README.md
+```
+
+The `services/` analyzers are one module per deterministic map: `coverage`, `symbols`, `datamodels`, `settings_map`, `schedules`, `ci_checks`, `release_map`, `contributing`, `entrypoints`, `commands`, `envscan`, `dependencies`, `integrations`, `error_handling`, `techdebt`, `docs`, `complexity`, `churn`, `activity`, `ownership`, `licenses`, `security`, `risk`, `health_score`, `apimap`, `glossary`, `filenames`, `package_purposes`, and `action_plan`.
+
+## Roadmap
+
+### Shipped
+
+The reading experience is already complete end to end: a plain-language project manual, hover annotations, a terminology dictionary, natural-language editing, and snippet Q&A, all in a bilingual UI you launch with one command (or as a native Tauri desktop app). On top of that sit a dozen deterministic, no-API-key maps — reading map, core-module ranking, a project-wide definition index with find-all-references (look up any name to jump to where it's declared and list every place it's used), test coverage, git-history hotspots and ownership, tech-debt markers, env-var surface, entry points, CLI commands, the data-model shapes a project declares (dataclasses, pydantic models, TypedDicts and NamedTuples, with their fields and types), the tunable settings hard-coded as UPPER_SNAKE constants (retry counts, timeouts, default model, feature flags — the values you might change without reading the code), the scheduled and automated tasks a project runs on its own (cron jobs, APScheduler/Celery beat timers, GitHub Actions schedules and JS timers — what fires without you pressing anything, with common cron expressions glossed into plain language), the CI quality gates a change has to pass on push or pull request (the lint, formatting, type-check, test, coverage, security and build steps wired up in GitHub Actions, pre-commit, GitLab CI, CircleCI, Jenkins and friends, each labelled in plain language so a red check stops being scary), how the project ships releases (where the current version lives, which versioning scheme it follows, whether there's a changelog, and whether pushing a tag or cutting a release auto-publishes to PyPI / npm / GitHub Release), how to get a change accepted (which file to read first, the PR and issue templates, and whether commits need a Signed-off-by/DCO, Conventional Commits, a CLA or a CODEOWNERS sign-off — the process steps that bounce a first pull request before anyone reads the code), external integrations, silent-failure spots, under-documented files, and logic complexity. It all exports offline too: every map stitches into a single `codemap.md`, or a self-contained HTML report you can email to a non-technical stakeholder — no server, no API key, nothing fetched from the network. Analyses also persist to a small on-disk library (`GET /api/projects`), so you can list past projects and reopen one without remembering its id or re-scanning.
+
+### Planned
+
+These are the directions I want to take next, roughly in priority order:
+
+- **Pull-request reading mode** — paste a PR link and get the diff explained in plain language: what changed, why it might matter, and which files to look at first. This is the most-requested extension and a natural fit for the existing annotation engine.
+- **Whole-project chat** — Q&A today is grounded in one file or snippet; the next step is a conversation that can reach across the project's maps and source at once, while staying honest about what it actually read.
+- **Annotation coverage beyond Python** — hover annotations lead with Python today; bringing JavaScript/TypeScript and Go up to the same depth is mostly prompt and tokenizer work.
+
+Have an idea or a codebase that confuses CodeABC? Open an issue — the roadmap is shaped by what real non-coders get stuck on.
+
+## Contributing
+
+Issues and PRs welcome. This project is in early development.
+
+## Related Projects
+
+CodeABC is one of several tools I've built for working with code. A few others you might like:
+
+- **[CoreCoder](https://github.com/he-yufeng/CoreCoder)** — want to understand how a coding agent really works? Read the whole ~1k-line engine end to end, not a black box.
+- **[RepoWiki](https://github.com/he-yufeng/RepoWiki)** — dropped into an unfamiliar codebase? It gives you a guided wiki and a where-to-start reading path, a self-hostable DeepWiki alternative.
+- **[FindJobs-Agent](https://github.com/he-yufeng/FindJobs-Agent)** — stop sifting job boards by hand: it ranks postings against your resume and runs mock interviews.
+- **[ContractGuard](https://github.com/he-yufeng/ContractGuard)** — catch the risky clauses before you sign: it reads contracts and flags the dangerous bits.
+- **[GitSense](https://github.com/he-yufeng/GitSense)** — want to contribute to open source? It finds issues worth your time and gauges whether your PR will get merged.
+
+## License
+
+MIT

codeabc-0.1.0.dist-info/RECORD

@@ -0,0 +1,62 @@
+backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+backend/app.py,sha256=diNqZZhw7NjIWG7OYR7fuwH16tMyLQIpP6o1AMtccbc,3059
+backend/desktop_server.py,sha256=WV8turtbOnckGwvDHvXZnov7hnDZaLOkZruTCnPGEC0,1441
+backend/models.py,sha256=bPHvSnh8IdXTGSTu4V1zzFFyUXTJKFikocbucSxgJNs,18055
+backend/prompts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+backend/prompts/annotate.py,sha256=Hiuz8QrWg5gh5dgZrfyMZjnB-HiDwR1nydtkc4XnPKA,1805
+backend/prompts/edit.py,sha256=dPlKxLNxpfHAnfU_hmWwIZtM103EY3j7dDXNfhOJxss,2111
+backend/prompts/overview.py,sha256=nQGN4NrbCYXxWIli0S1CzttF4SoHrlIPLceW08UbAL4,2158
+backend/prompts/qa.py,sha256=6g2crmr7uM4XnlqzE0juXuUtzyaXlPLly58DCE1mDN0,1653
+backend/routers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+backend/routers/analyze.py,sha256=kXyXO785zHEiwqWL6j77roBM2KZ_TiDyc6vSgI8LQh8,9474
+backend/routers/project.py,sha256=HPcen_cbJlfzsUwXTbgq1D4U3E0xT-a_5etPy-ATzr8,32483
+backend/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+backend/services/action_plan.py,sha256=9-drt30acjZ-gX7h5FeelcYIhAaYJH-DaqdGGbiKi5E,14649
+backend/services/activity.py,sha256=86cDXEN_1eBrL9CWRM4U4avQUTC2r7wY_3UQvw0gopY,11125
+backend/services/apimap.py,sha256=-CNwurd5kvUCPL3DUzf5e2OV1zGY3Zclim-UMEs8w9w,13988
+backend/services/async_surface.py,sha256=vlLAeqh-pTaIFNRQLgDEXAmhOxJ9aYzF46AYDh_x3Io,4807
+backend/services/cache.py,sha256=HFZ5g6ZpZJQAE5nb3TrZTsckGlLtXSXUxVZdjo8I7sM,5548
+backend/services/churn.py,sha256=rPu3uwCLEcav0rPzN9PjeRC3zpoha-wEMXEBo36fXI4,8868
+backend/services/ci_checks.py,sha256=SvLbQnznZ4m3-1iUbM8eoM1bbMCmuxiSvz_2xc6sG4A,13434
+backend/services/codemap_export.py,sha256=cjYQLHo0QB-LottxnQdGCMmZz40Qbi6-WxoUwW0KJEE,5486
+backend/services/commands.py,sha256=Ayr9_6uSRPhFtbSCIztdgy_lxPrfDePdk3Y08GUxDG4,10214
+backend/services/complexity.py,sha256=_YvNwUtciivFf0708ubVJRratMePBjTBxL1Ri46jUaU,4514
+backend/services/config_files.py,sha256=ksIO6FfaANeHsk1BZSW35GKRMe8hKWD7EdRN0qeZ6Og,8230
+backend/services/contributing.py,sha256=nn05dpsEsRgR9YzuCz8u7Mz0Zhc5e87vuYJ40C53Twc,12339
+backend/services/coverage.py,sha256=1eyMb1l8R_2iOM5WiqPL1bQ3uxFp6m5MYNsl2--zAn4,11410
+backend/services/datamodels.py,sha256=UacxLqeQ5gZB_Vggfg5aVI7nJSyHZ6Nwg-ItwnPm0Lw,6960
+backend/services/deep_nesting.py,sha256=-HhPToh16jbo3YCGfpLPIVrEqHtb7z5pLEZFxXUzRfg,4326
+backend/services/dependencies.py,sha256=KqWFsGmixdFvz-hPWpnaQ089XiecAVxPdlaD25NfgFo,10342
+backend/services/docs.py,sha256=9bzTtlVgnw0uu7tfx0yT8OnjptqThsIm8kvMHWK17b0,8076
+backend/services/docstrings.py,sha256=VPBQETdldMRf4l--nDZxeHA_86yAwE0LH6OMcOaYC8E,6736
+backend/services/duplicate_code.py,sha256=8uybJ21JAIGK7BW4Ff7Zp4OjfsY9WkuXs7fCnK2HR7E,6776
+backend/services/entrypoints.py,sha256=gvT4ebaKYaUXZqkmbjYEt52svWGh47A9FhWn_K5rqDs,6417
+backend/services/envscan.py,sha256=_0WLGL2O3FO5xt9RG1q5VL9MqyhXbZD5OnJ9-UnfQaE,7724
+backend/services/error_handling.py,sha256=_tm8z71nD08SNAlDE-2XB5Mkhr7svhnUhQgzGKY_Vo0,8889
+backend/services/filenames.py,sha256=W01M2z1pm26JT2ONKD3sG3oELUygnglZ9T0ir7QxKcU,11875
+backend/services/github_clone.py,sha256=JXjr2T76R_9anJlxCiJL2LDZc2tjfexg6gRIyEj1n3I,4393
+backend/services/glossary.py,sha256=fyZu1wEy0UF9LXYvIPMA-WC3YtWC9zSzsg9gSxaH6WU,7035
+backend/services/health_score.py,sha256=RFMu-cEJVH_6JxzfbaIcfQ90nTs4HqoOplQqOrfZL_A,13977
+backend/services/importgraph.py,sha256=Ukqub7SHZXlo0MuPf2PLf0L2Aa_RwpWK8ZDiOTwe_dg,37178
+backend/services/integrations.py,sha256=PTY2W5R7FdQcKwzR7GmN8nx3x7WYXTk1ahA55ehUolg,11699
+backend/services/licenses.py,sha256=wKvmbL-OVgk5h_YBpeOr_DI1jV352WP1LMkTroCOtqQ,23126
+backend/services/llm.py,sha256=BFKOIxPkO8vIsdzMRMgQus5kWd564EzKBgm3BHzQi68,4410
+backend/services/long_functions.py,sha256=gDQrYsU-WE9wSQgI6ZkDS7gmakWeOACgpXqKyCJzVX4,4452
+backend/services/ownership.py,sha256=4BzcCbYEht-Wv8YHEjepfzhzutoT10LEpDRVhqTZnY0,7311
+backend/services/package_purposes.py,sha256=LIjvOPcfSdF2ynhHqQMaTnhcl4tyyPYNFy5Nz2t1j6c,7162
+backend/services/pr_reading.py,sha256=DbTV3drBO9p8ncb6Y55Y7kghbNe8TWQ_PaHqEYPgkbM,6222
+backend/services/release_map.py,sha256=nimpVDnqg8SWTQ5tgeBaW-1HCC3VkwmvGwbvnqlp61A,15998
+backend/services/report_export.py,sha256=vxzSuwGx7l6HvL_BzyfjRMVilyutcamfx9Qxscb4rps,8529
+backend/services/risk.py,sha256=NNtInmaklWz6MYsOMwPg0_VKmQ_Wtrdj2sk4LhikTbM,3375
+backend/services/scanner.py,sha256=jcxuGLqyRJFaY2D-JcO9yGbqLz3g5ujONItROZqIxSY,13840
+backend/services/schedules.py,sha256=hfdwIQyQ6YF2Nq_dK0Tn9fx2RP8KJsySiuKyBpqJr9c,14288
+backend/services/security.py,sha256=IP3ahBETdw2ZXeQB4X0gLZSAiakpg9YlpxKQKaA00zM,17551
+backend/services/settings_map.py,sha256=OQiX3EcfQqf14pgPoXlYGCV1bdOMzlX8BvMzG_Cl0O8,8814
+backend/services/symbols.py,sha256=2sLmLavz0OeJF0IBCV6msWwE1wBlMhkHpl1-SQJKTno,24799
+backend/services/techdebt.py,sha256=og7-mzIsYjKzYRHOnO0DVKmnjDrOgeyZ2FVhHoy0Jsw,4720
+backend/services/too_many_params.py,sha256=z4VW2uX13iameFhmzjby8qgu1YUGBCWVDsT6ITj-aGs,4432
+backend/services/typing_coverage.py,sha256=4qH_HnXlzK1OJtm6gD5QZp2qaePj5k1eIcS70XlZF_U,7451
+codeabc-0.1.0.dist-info/METADATA,sha256=O_hqIJ0j974CzlePLFxHCZfTyOFPgkm_MHc_HrzSqyc,20343
+codeabc-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+codeabc-0.1.0.dist-info/licenses/LICENSE,sha256=Gjpln1GILd5PHMjjXZpdojQ-DGlvmxFP_nr19R6m9xo,1066
+codeabc-0.1.0.dist-info/RECORD,,

codeabc-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

codeabc-0.1.0.dist-info/licenses/LICENSE

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