codeabc 0.1.2__py3-none-any.whl → 0.1.3__py3-none-any.whl

backend/models.py

@@ -183,6 +183,21 @@ class ErrorHandling(BaseModel):
     notes: list[str] = []
 
 
+class UnusedExport(BaseModel):
+    path: str
+    name: str
+    kind: str  # "function" | "class"
+    line: int
+    reason: str  # plain-language explanation for a non-programmer
+
+
+class UnusedExports(BaseModel):
+    total: int = 0
+    files_affected: int = 0
+    findings: list[UnusedExport] = []
+    notes: list[str] = []
+
+
 class ExternalService(BaseModel):
     name: str
     category: str  # AI / 大模型 | 云服务 | 数据库 | 支付 | 通讯 | ...
@@ -202,6 +217,7 @@ class EnvVar(BaseModel):
     name: str
     required: bool  # read via os.environ["X"] somewhere, so it must be set
     count: int = 1  # how many places read it
+    documented: bool = True  # mentioned in .env.example / README / docs anywhere
 
 
 class EntryPoint(BaseModel):
@@ -484,6 +500,7 @@ class ProjectMeta(BaseModel):
     action_plan: ActionPlan | None = None
     doc_coverage: DocCoverage | None = None
     error_handling: ErrorHandling | None = None
+    unused_exports: UnusedExports | None = None
     integrations: Integrations | None = None
     release: ReleaseSummary | None = None
     contribution: ContributionGuide | None = None
@@ -614,7 +631,10 @@ class FileOutline(BaseModel):
 
 
 class GitHubRequest(BaseModel):
-    url: str = Field(..., pattern=r"^https?://github\.com/.+/.+")
+    # Shape validation lives in github_clone._parse_github_url, which already
+    # accepts bare github.com/... links, inner-page URLs, git@ SSH and the
+    # owner/repo shorthand; a regex here rejected those before reaching it.
+    url: str = Field(..., min_length=1, description="GitHub URL or owner/repo shorthand")
 
 
 class UploadedFile(BaseModel):

backend/routers/project.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import uuid
 
-from fastapi import APIRouter, HTTPException
+from fastapi import APIRouter, HTTPException, Request
 from fastapi.responses import Response
 
 from backend.models import (
@@ -71,6 +71,8 @@ from backend.models import (
     TechDebtFile,
     TestCoverageSummary,
     TunableSetting,
+    UnusedExport,
+    UnusedExports,
     UploadedFile,
 )
 from backend.services import (
@@ -116,6 +118,7 @@ from backend.services import (
     techdebt,
     too_many_params,
     typing_coverage,
+    unused_exports,
 )
 from backend.services import (
     health_score as health_score_svc,
@@ -252,6 +255,7 @@ def _content_analyses(
     """
     tech_debt = techdebt.scan_tech_debt(file_contents)
     env = envscan.scan_env_vars(file_contents)
+    undocumented_env = set(envscan.find_undocumented_env_vars(env, file_contents))
     entries = entrypoints.find_entry_points(file_contents)
     cli_commands = commands.find_cli_commands(file_contents)
     data_models = datamodels.find_data_models(file_contents)
@@ -266,6 +270,7 @@ def _content_analyses(
     api = apimap.scan_api_routes(file_contents)
     doc = docs.assess_doc_coverage(file_contents)
     silent = error_handling.find_swallowed_errors(file_contents)
+    dead = unused_exports.find_unused_exports(file_contents)
     integ = integrations.detect_external_services(file_contents)
     rel = release_map.find_release_info(file_contents)
     contrib = contributing.find_contribution_guide(file_contents)
@@ -285,7 +290,13 @@ def _content_analyses(
             TechDebtFile(path=f["path"], count=f["count"]) for f in tech_debt["files"]
         ],
         "env_vars": [
-            EnvVar(name=v["name"], required=v["required"], count=v["count"]) for v in env["vars"]
+            EnvVar(
+                name=v["name"],
+                required=v["required"],
+                count=v["count"],
+                documented=v["name"] not in undocumented_env,
+            )
+            for v in env["vars"]
         ],
         "entry_points": [
             EntryPoint(path=e["path"], kind=e["kind"], command=e["command"], reason=e["reason"])
@@ -410,6 +421,12 @@ def _content_analyses(
             findings=[SilentFailure(**f) for f in silent["findings"]],
             notes=silent["notes"],
         ),
+        "unused_exports": UnusedExports(
+            total=dead["total"],
+            files_affected=dead["files_affected"],
+            findings=[UnusedExport(**f) for f in dead["findings"]],
+            notes=dead["notes"],
+        ),
         "integrations": Integrations(
             total=integ["total"],
             services=[ExternalService(**s) for s in integ["services"]],
@@ -796,15 +813,20 @@ async def get_references(project_id: str, name: str):
 
 
 @router.get("/pr-reading")
-async def get_pr_reading(url: str):
+async def get_pr_reading(url: str, request: Request, explain: bool = False):
     """Turn a PR link into a plain-language diff walkthrough.
 
-    Deterministic (no LLM): fetches the PR's unified diff, breaks it into
-    per-file changes with add/del counts, classifies each file as code, test,
-    docs, or config, and proposes a review reading order (biggest production
-    diffs first). An LLM explanation layer can sit on this payload later.
+    The deterministic core (no LLM) fetches the PR's unified diff, breaks it
+    into per-file changes with add/del counts, classifies each file as code,
+    test, docs, or config, and proposes a review reading order (biggest
+    production diffs first). With explain=true the payload also carries
+    per-file plain-language explanations: LLM-written when the caller passes
+    an x-api-key, deterministic diff-derived notes otherwise.
     """
     try:
+        if explain:
+            api_key = request.headers.get("x-api-key")
+            return await pr_reading.analyze_pr_explained(url, explain=True, api_key=api_key)
         return pr_reading.analyze_pr(url)
     except ValueError as exc:
         raise HTTPException(400, str(exc)) from exc

backend/services/action_plan.py

@@ -198,6 +198,13 @@ def _too_many_params_actions(too_many_params_files: list[dict] | None) -> list[d
     return actions
 
 
+def _missing_count(f: dict) -> int:
+    # typing_coverage emits the sample of unannotated symbol names (a list);
+    # older cached payloads may carry a bare count. Either way compare counts.
+    m = f.get("missing", 0)
+    return len(m) if isinstance(m, list) else m
+
+
 def _typing_actions(typing_files: list[dict] | None) -> list[dict]:
     if not typing_files:
         return []
@@ -205,11 +212,11 @@ def _typing_actions(typing_files: list[dict] | None) -> list[dict]:
     # Files with the most unannotated public symbols and low coverage first;
     # only surface genuinely under-annotated files (not a stray missing hint).
     weak = sorted(
-        (f for f in typing_files if f.get("missing", 0) >= 3 and f.get("coverage", 1) < 0.6),
-        key=lambda f: (-f.get("missing", 0), f.get("coverage", 1)),
+        (f for f in typing_files if _missing_count(f) >= 3 and f.get("coverage", 1) < 0.6),
+        key=lambda f: (-_missing_count(f), f.get("coverage", 1)),
     )
     for f in weak[:_MAX_PER_CATEGORY]:
-        missing = f.get("missing", 0)
+        missing = _missing_count(f)
         pct = round(f.get("coverage", 0) * 100)
         actions.append(
             {

backend/services/envscan.py

@@ -165,3 +165,47 @@ def render_env_markdown(project_name: str, env_data: dict | None) -> str:
         lines.append("")
 
     return "\n".join(lines).rstrip() + "\n"
+
+
+_DOC_BASENAMES = (
+    ".env.example",
+    ".env.sample",
+    ".env.template",
+    ".env.defaults",
+)
+
+
+def _is_doc_candidate(path: str) -> bool:
+    """Whether a file is a place a newcomer would look for env configuration."""
+    lower = path.lower()
+    base = lower.rsplit("/", 1)[-1]
+    if base in _DOC_BASENAMES or base.startswith("readme"):
+        return True
+    if base.endswith(".md") and (
+        "/" not in lower or lower.startswith(("docs/", "doc/", ".github/"))
+    ):
+        return True
+    return False
+
+
+def find_undocumented_env_vars(scan: dict, file_contents: dict[str, str]) -> list[str]:
+    """Names of env vars that no documentation file mentions.
+
+    ``.env.example`` and the README are where a newcomer learns what to
+    configure; a variable the code reads but nobody writes down is a setup
+    landmine, doubly so when it is required. Matching is a whole-word search
+    over every documentation candidate, so ``HOST`` does not count as
+    documented just because ``DB_HOST`` appears. Pure over the scan result and
+    the file texts, so it is unit-testable with plain dicts.
+    """
+    doc_text = "\n".join(
+        content for path, content in file_contents.items() if _is_doc_candidate(path)
+    )
+    undocumented = []
+    for var in scan.get("vars", []):
+        name = var.get("name")
+        if not name:
+            continue
+        if not re.search(rf"(?<![A-Za-z0-9_]){re.escape(name)}(?![A-Za-z0-9_])", doc_text):
+            undocumented.append(name)
+    return undocumented

backend/services/pr_reading.py

@@ -7,6 +7,7 @@ order. An LLM explanation layer can sit on top of this payload later.
 
 from __future__ import annotations
 
+import asyncio
 import json
 import re
 import subprocess
@@ -179,3 +180,131 @@ def render_markdown(analysis: dict) -> str:
 
 def to_json(analysis: dict) -> str:
     return json.dumps(analysis, ensure_ascii=False, indent=2)
+
+
+_EXPLAIN_MAX_FILES = 8
+_DIFF_EXCERPT_MAX_LINES = 120
+
+_SYMBOL_RE = re.compile(
+    r"^\+\s*(?:async\s+def|def|class|function|export\s+(?:async\s+)?function|export\s+class)\s+([A-Za-z_][\w]*)"
+)
+
+
+def _diff_sections(diff_text: str) -> dict[str, list[str]]:
+    """Map each file path to its raw diff lines (headers + hunks)."""
+    sections: dict[str, list[str]] = {}
+    current: str | None = None
+    for line in diff_text.splitlines():
+        if line.startswith("diff --git "):
+            match = re.match(r"diff --git a/(\S+) b/(\S+)", line)
+            current = match.group(2) if match else None
+            if current is not None:
+                sections[current] = [line]
+        elif current is not None:
+            sections[current].append(line)
+    return sections
+
+
+def _symbols_from_excerpt(excerpt_lines: list[str]) -> list[str]:
+    names: list[str] = []
+    for line in excerpt_lines:
+        m = _SYMBOL_RE.match(line)
+        if m and m.group(1) not in names:
+            names.append(m.group(1))
+    return names
+
+
+def _deterministic_note(change: FileChange, excerpt_lines: list[str]) -> str:
+    """Plain-language note without any LLM: what kind of file it is, its size, and the
+    functions/classes it adds or updates (from added definition lines in the diff)."""
+    symbols = _symbols_from_excerpt(excerpt_lines)
+    base = {
+        "code": "production code",
+        "test": "test",
+        "docs": "documentation",
+        "config": "configuration",
+    }.get(change.change_type, "other")
+    size = f"+{change.added} / -{change.deleted} lines"
+    if symbols:
+        return f"This {base} file ({size}) adds or updates: {', '.join(symbols[:6])}."
+    return f"This {base} file ({size}) is edited; open it to see the exact changes."
+
+
+def _excerpt(lines: list[str]) -> str:
+    if len(lines) <= _DIFF_EXCERPT_MAX_LINES:
+        return "\n".join(lines)
+    head = "\n".join(lines[:_DIFF_EXCERPT_MAX_LINES])
+    return head + f"\n... ({len(lines) - _DIFF_EXCERPT_MAX_LINES} more diff lines trimmed)"
+
+
+async def explain_files(
+    files: list[FileChange],
+    diff_text: str,
+    *,
+    api_key: str | None = None,
+    model: str | None = None,
+) -> dict[str, str]:
+    """Plain-language note per file. LLM-backed when a key is configured; otherwise a
+    deterministic note built from the diff itself, so the feature works key-free."""
+    from backend.services.llm import call_llm, is_error_text
+
+    sections = _diff_sections(diff_text)
+    out: dict[str, str] = {}
+
+    async def explain_one(change: FileChange) -> tuple[str, str]:
+        excerpt_lines = sections.get(change.path, [])
+        excerpt = _excerpt(excerpt_lines)
+        fallback = _deterministic_note(change, excerpt_lines)
+        if not api_key:
+            return change.path, fallback
+        prompt = (
+            "You are explaining one file's part of a pull request to someone who does not code.\n"
+            f"File: {change.path} ({change.change_type}, +{change.added} / -{change.deleted}).\n"
+            f"Diff excerpt:\n{excerpt}\n\n"
+            "In 2-3 plain sentences: what changed in this file and why it might matter. "
+            "No jargon; say the file name, not the path, when you refer to it."
+        )
+        text = (await call_llm(prompt, api_key=api_key, model=model)).strip()
+        if not text or is_error_text(text):
+            return change.path, fallback
+        return change.path, text
+
+    ordered = files[:_EXPLAIN_MAX_FILES]
+    results = await asyncio.gather(*(explain_one(f) for f in ordered))
+    out.update(results)
+    # Files beyond the cap still get the deterministic note so the UI never shows a gap.
+    for f in files[_EXPLAIN_MAX_FILES:]:
+        out[f.path] = _deterministic_note(f, sections.get(f.path, []))
+    return out
+
+
+async def analyze_pr_explained(
+    url: str, *, explain: bool, api_key: str | None = None, model: str | None = None
+) -> dict:
+    """analyze_pr plus optional per-file explanations (LLM when keyed, deterministic otherwise)."""
+    ref = parse_pr_url(url)
+    diff_text = await asyncio.to_thread(fetch_pr_diff, ref)
+    files = parse_diff_files(diff_text)
+    ordered = reading_order(files)
+    analysis = {
+        "url": url,
+        "owner": ref.owner,
+        "repo": ref.repo,
+        "number": ref.number,
+        "summary": summarize_diff(files),
+        "files": [
+            {
+                "path": f.path,
+                "added": f.added,
+                "deleted": f.deleted,
+                "change_type": f.change_type,
+                "hunks": f.hunks,
+            }
+            for f in ordered
+        ],
+    }
+    if explain:
+        analysis["explanations"] = await explain_files(
+            ordered, diff_text, api_key=api_key, model=model
+        )
+    return analysis

backend/services/unused_exports.py

@@ -0,0 +1,185 @@
+"""Unused exports: public symbols that nothing else in the project references.
+
+Orphan modules answer "which files does nobody import?". This answers the
+finer question one level down: "which functions and classes inside otherwise
+used files does nobody call?". A public helper that was written for a caller
+that no longer exists is dead weight a new reader still has to load into
+their head, and it tends to be the code that breaks first in a refactor
+because nothing exercises it.
+
+:func:`find_unused_exports` walks the already-read file contents and flags
+top-level ``def`` / ``class`` definitions (Python) and ``export``ed
+``function`` / ``class`` / ``const`` declarations (JS/TS) whose name never
+shows up anywhere outside their own file.
+
+It deliberately stays conservative to keep the signal worth reading:
+
+* Anything decorated is skipped. Decorators are how frameworks register
+  things (FastAPI routes, pytest fixtures, click commands, tasks), and a
+  decorated definition is used by the framework even when no caller is
+  visible in the text.
+* Dunder names, private names (leading ``_``), and definitions inside test
+  files are skipped. Tests are consumers, not candidates.
+* A definition referenced only inside its own module still counts as a
+  candidate: a public symbol used only locally is effectively private and
+  could have been a ``_helper``.
+
+Findings are *candidates for human review, not verdicts*. String references,
+``getattr`` lookups, dynamic imports, and re-export barrels are not tracked,
+so anything here deserves a second look before deletion.
+"""
+
+from __future__ import annotations
+
+import re
+
+_PY = {"py", "pyi"}
+_JSTS = {"js", "jsx", "ts", "tsx", "mjs", "cjs", "mts", "cts"}
+
+_TEST_SEGMENTS = {"test", "tests", "__tests__", "spec", "specs"}
+
+_PY_DEF_RE = re.compile(r"^(async\s+def|def|class)\s+([A-Za-z_][A-Za-z0-9_]*)")
+_JS_EXPORT_RE = re.compile(
+    r"^\s*export\s+(?:async\s+)?(?:function|class|const|let)\s+([A-Za-z_$][A-Za-z0-9_$]*)"
+)
+
+# Names that look dead but are entry points by convention.
+_ENTRY_NAMES = {
+    "main",
+    "app",
+    "application",
+    "handler",
+    "create_app",
+    "run",
+    "cli",
+    "register",
+    "setup",
+    "teardown",
+    "ready",
+    "default",
+}
+
+_MAX_FINDINGS = 200
+
+
+def _ext(path: str) -> str:
+    name = path.rsplit("/", 1)[-1].rsplit("\\", 1)[-1]
+    return name.rsplit(".", 1)[-1].lower() if "." in name else ""
+
+
+def _is_test(path: str) -> bool:
+    norm = path.replace("\\", "/")
+    segments = [s for s in norm.split("/") if s]
+    if any(s in _TEST_SEGMENTS for s in segments):
+        return True
+    name = segments[-1] if segments else ""
+    stem = name.rsplit(".", 1)[0] if "." in name else name
+    return stem.startswith("test_") or stem.endswith("_test") or ".test" in name or ".spec" in name
+
+
+def _collect_python_defs(path: str, text: str) -> list[dict]:
+    """Top-level, undecorated def/class definitions in one Python file."""
+    defs: list[dict] = []
+    pending_decorated = False
+    for lineno, line in enumerate(text.splitlines(), start=1):
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#"):
+            continue
+        indent = len(line) - len(line.lstrip())
+        if stripped.startswith("@"):
+            if indent == 0:
+                pending_decorated = True
+            continue
+        if indent != 0:
+            pending_decorated = False
+            continue
+        m = _PY_DEF_RE.match(line)
+        if not m:
+            pending_decorated = False
+            continue
+        name = m.group(2)
+        decorated = pending_decorated
+        pending_decorated = False
+        if decorated or name.startswith("_") or name in _ENTRY_NAMES:
+            continue
+        kind = "class" if m.group(1) == "class" else "function"
+        defs.append({"path": path, "name": name, "kind": kind, "line": lineno})
+    return defs
+
+
+def _collect_js_defs(path: str, text: str) -> list[dict]:
+    defs: list[dict] = []
+    for lineno, line in enumerate(text.splitlines(), start=1):
+        m = _JS_EXPORT_RE.match(line)
+        if not m:
+            continue
+        name = m.group(1)
+        if name.startswith("_") or name in _ENTRY_NAMES:
+            continue
+        kind = "class" if "class" in line.split("export", 1)[1].split(name)[0] else "function"
+        defs.append({"path": path, "name": name, "kind": kind, "line": lineno})
+    return defs
+
+
+def _referenced_outside(name: str, home: str, contents: dict[str, str]) -> bool:
+    """True when the name appears anywhere outside its own file.
+
+    Test files count as consumers here: a symbol exercised only by tests is
+    alive, it is just not part of the runtime surface.
+    """
+    word = re.compile(r"\b" + re.escape(name) + r"\b")
+    for path, text in contents.items():
+        if path == home:
+            continue
+        if word.search(text):
+            return True
+    return False
+
+
+def _referenced_locally_only(name: str, home: str, text: str) -> bool:
+    """True when the name is used in its own file beyond the definition line."""
+    return len(re.findall(r"\b" + re.escape(name) + r"\b", text)) > 1
+
+
+def find_unused_exports(file_contents: dict[str, str]) -> dict:
+    """Flag public definitions with no references outside their own file.
+
+    Returns a summary dict with ``total``, ``files_affected``, ``findings``
+    (path/name/kind/line/reason), and ``notes`` explaining the blind spots.
+    """
+    candidates: list[dict] = []
+    for path, text in file_contents.items():
+        ext = _ext(path)
+        if ext not in _PY and ext not in _JSTS:
+            continue
+        if _is_test(path):
+            continue
+        defs = _collect_python_defs(path, text) if ext in _PY else _collect_js_defs(path, text)
+        for d in defs:
+            if _referenced_outside(d["name"], path, file_contents):
+                continue
+            local = _referenced_locally_only(d["name"], path, text)
+            reason = (
+                f"public {d['kind']} used only inside its own module; "
+                "nothing imports it elsewhere (effectively private)"
+                if local
+                else f"public {d['kind']} with no references anywhere else in the project"
+            )
+            candidates.append({**d, "reason": reason})
+
+    candidates.sort(key=lambda c: (c["path"], c["line"]))
+    findings = candidates[:_MAX_FINDINGS]
+    return {
+        "total": len(candidates),
+        "files_affected": len({c["path"] for c in candidates}),
+        "findings": findings,
+        "notes": [
+            "Findings are candidates for human review, not proof of dead code: "
+            "string references, getattr, dynamic imports, and re-export barrels "
+            "are not tracked.",
+            "Decorated definitions are skipped because frameworks (FastAPI, "
+            "pytest, click, task queues) register them without a visible caller.",
+            "A symbol used only inside its own module is flagged as effectively "
+            "private, not necessarily dead.",
+        ],
+    }

{codeabc-0.1.2.dist-info → codeabc-0.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: codeabc
-Version: 0.1.2
+Version: 0.1.3
 Summary: AI-powered code reader for non-programmers
 Author-email: Yufeng He <40085740+he-yufeng@users.noreply.github.com>
 License-Expression: MIT
@@ -22,7 +22,7 @@ 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: litellm!=1.100.0,!=1.98.0,!=1.99.0,>=1.40.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: python-multipart>=0.0.9
 Requires-Dist: uvicorn[standard]>=0.30.0
@@ -125,6 +125,10 @@ Before trusting a script you didn't write, you usually want to know what it reac
 
 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 Functions Does Nobody Call?
+
+Orphan modules tell you which files nobody imports; this goes one level finer and asks which functions and classes inside otherwise used files nobody calls. A public helper written for a caller that no longer exists is dead weight every reader still has to load into their head, and it is usually the code that breaks first in a refactor because nothing exercises it. CodeABC flags top-level functions, classes, and exported symbols whose name never appears outside their own file, with the reasoning spelled out. Decorated definitions (routes, fixtures, commands) are skipped on purpose, and the report calls itself a candidate list for human review rather than a verdict, because string references and dynamic imports are invisible to any text scan.
+
 ### 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.

{codeabc-0.1.2.dist-info → codeabc-0.1.3.dist-info}/RECORD

@@ -1,7 +1,7 @@
 backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 backend/app.py,sha256=diNqZZhw7NjIWG7OYR7fuwH16tMyLQIpP6o1AMtccbc,3059
 backend/desktop_server.py,sha256=sBMYZOxoa2diFMtVAALJvqCyntmf6uEvYFu4xVz3D1M,1875
-backend/models.py,sha256=bPHvSnh8IdXTGSTu4V1zzFFyUXTJKFikocbucSxgJNs,18055
+backend/models.py,sha256=UmP2DdvOYGC4xLP8JYAPlbbbIKIA5HvUvQZf-4gf7vk,18763
 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
@@ -9,9 +9,9 @@ backend/prompts/overview.py,sha256=nQGN4NrbCYXxWIli0S1CzttF4SoHrlIPLceW08UbAL4,2
 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/routers/project.py,sha256=H6YqbBZiDTSQcmAQNffPmliUqvUv6qk8KifLNcW6nUE,33410
 backend/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-backend/services/action_plan.py,sha256=9-drt30acjZ-gX7h5FeelcYIhAaYJH-DaqdGGbiKi5E,14649
+backend/services/action_plan.py,sha256=cMOHFzVVplsR1OSZGNkBqiD9rM7ON-1qE__NQVk6Clg,14913
 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
@@ -31,7 +31,7 @@ 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/envscan.py,sha256=7QY-zymr4NV5WMxZLWiDUla28bQKvMKz4EcRAz3wvfM,9247
 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
@@ -44,7 +44,7 @@ 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/pr_reading.py,sha256=HGYM7Wp8Aqi5fU_e26A3m4K5NK0pm_vO-PjiFLun1IE,11010
 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
@@ -56,8 +56,9 @@ backend/services/symbols.py,sha256=2sLmLavz0OeJF0IBCV6msWwE1wBlMhkHpl1-SQJKTno,2
 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.2.dist-info/METADATA,sha256=7ngPjg1Xb_VCdqiBQqJiLY8LzadbVEiRiMMi1-kwJ8k,20343
-codeabc-0.1.2.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-codeabc-0.1.2.dist-info/entry_points.txt,sha256=VX1hw16wgWy0owLA2Dgc7FPh0tx3qWFbBvBuTKSLj9o,60
-codeabc-0.1.2.dist-info/licenses/LICENSE,sha256=Gjpln1GILd5PHMjjXZpdojQ-DGlvmxFP_nr19R6m9xo,1066
-codeabc-0.1.2.dist-info/RECORD,,
+backend/services/unused_exports.py,sha256=4_lm7Xr9-xl9ZuLbeVLj9zybx3oHPMn4kzXChB8Kmuc,7033
+codeabc-0.1.3.dist-info/METADATA,sha256=ylszuXllXMlIacMSOLP74Ks7WmQ1npSaijFQRuaXwos,21163
+codeabc-0.1.3.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+codeabc-0.1.3.dist-info/entry_points.txt,sha256=VX1hw16wgWy0owLA2Dgc7FPh0tx3qWFbBvBuTKSLj9o,60
+codeabc-0.1.3.dist-info/licenses/LICENSE,sha256=Gjpln1GILd5PHMjjXZpdojQ-DGlvmxFP_nr19R6m9xo,1066
+codeabc-0.1.3.dist-info/RECORD,,

{codeabc-0.1.2.dist-info → codeabc-0.1.3.dist-info}/WHEEL

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