Task 1. Clone repository và khám phá file

import os
import sys
import json
import subprocess
from pathlib import Path
from collections import Counter
import statistics

# Resolve PROJECT_ROOT using Git
PROJECT_ROOT = Path(
    subprocess.run(
        ["git", "rev-parse", "--show-toplevel"],
        check=True,
        capture_output=True,
        text=True,
    ).stdout.strip()
)

sys.path.insert(0, str(PROJECT_ROOT / "src"))
from infrastructure.filesystem.git_source_repository import GitSourceRepository

SOURCE_REPOSITORY = PROJECT_ROOT / "workspace/source/transformers-pr-agent"
MANIFEST_PATH = PROJECT_ROOT / "artifacts/manifests/source-files.jsonl"
print("PROJECT_ROOT:", PROJECT_ROOT)
print("SOURCE_REPOSITORY:", SOURCE_REPOSITORY)
print("MANIFEST_PATH:", MANIFEST_PATH)

# Execute CLI clone command
print("Executing clone-source CLI...")
subprocess.run(
    ["uv", "run", "lab04", "clone-source"],
    check=True,
    text=True,
    cwd=str(PROJECT_ROOT)
)

# Verification using Git
remote_url = subprocess.check_output(
    ["git", "-C", str(SOURCE_REPOSITORY), "remote", "get-url", "origin"],
    text=True,
).strip()
commit_hash = subprocess.check_output(
    ["git", "-C", str(SOURCE_REPOSITORY), "rev-parse", "HEAD"],
    text=True,
).strip()
is_shallow = subprocess.check_output(
    ["git", "-C", str(SOURCE_REPOSITORY), "rev-parse", "--is-shallow-repository"],
    text=True,
).strip()

print("Remote URL:", remote_url)
print("Commit SHA:", commit_hash)
print("Shallow repository:", is_shallow)

# Run discovery CLI command
print("Executing discover CLI...")
subprocess.run(
    ["uv", "run", "lab04", "discover", "--scope", "final", "--manifest", str(MANIFEST_PATH)],
    check=True,
    text=True,
    cwd=str(PROJECT_ROOT)
)

# Read and summarize manifest generated by CLI/service
manifest_records = []
with open(MANIFEST_PATH, "r", encoding="utf-8") as f:
    for line in f:
        manifest_records.append(json.loads(line))

raw_files = manifest_records
eligible_files = [record for record in manifest_records if record["included"]]
excluded_files = [record for record in manifest_records if not record["included"]]

repo_adapter = GitSourceRepository(SOURCE_REPOSITORY, clone_url="")
previous_scope = os.environ.get("PARSER_SCOPE")
os.environ["PARSER_SCOPE"] = "final"
independent_eligible_paths = [path.as_posix() for path in repo_adapter.list_files()]
os.environ["PARSER_SCOPE"] = "smoke"
smoke_paths = [path.as_posix() for path in repo_adapter.list_files()]
if previous_scope is None:
    os.environ.pop("PARSER_SCOPE", None)
else:
    os.environ["PARSER_SCOPE"] = previous_scope

raw_paths = [record["file_path"] for record in raw_files]
eligible_paths = [record["file_path"] for record in eligible_files]
src_paths = [path for path in raw_paths if path.startswith("src/")]
exclusion_counts = Counter(record["exclusion_reason"] for record in excluded_files)
by_top_level = Counter(Path(path).parts[0] for path in raw_paths)

print("Raw Python files in repository:", len(raw_paths))
print("Python files under src/:", len(src_paths))
print("Eligible Python files after exclusions:", len(eligible_paths))
print("Full manifest count:", len(eligible_paths))
print("Files selected for smoke verification:", len(smoke_paths))

print("\nBreakdown by top-level directory:")
for name, count in by_top_level.most_common():
    print(f"{name}: {count}")

print("\nExclusion rules and counts:")
for reason, count in sorted(exclusion_counts.items()):
    print(f"{reason}: {count}")

sizes = [record["size_bytes"] for record in eligible_files]
print("\nEligible file size statistics (bytes):")
print("Min size:", min(sizes))
print("Max size:", max(sizes))
print("Mean size:", statistics.mean(sizes))
print("Median size:", statistics.median(sizes))

repo_ids = {record["repository_id"] for record in eligible_files}
commit_shas = {record["commit_sha"] for record in eligible_files}
print(f"\nRepository ID: {list(repo_ids)[0]}")
print(f"Commit SHA in manifest: {list(commit_shas)[0]}")

print("\nSample eligible paths:")
for path in eligible_paths[:20]:
    print(path)

print("\nSample smoke paths:")
for path in smoke_paths[:10]:
    print(path)

# Task 1 Verification Assertions
assert SOURCE_REPOSITORY.exists(), "Source repository path does not exist"
assert (SOURCE_REPOSITORY / ".git").exists(), "Not a git repository"
assert is_shallow == "true", "Repository is not shallow"
assert MANIFEST_PATH.exists(), "Manifest file does not exist"
assert len(raw_files) > 0, "Raw manifest is empty"
assert len(eligible_files) > 0, "Eligible manifest is empty"

assert len(raw_paths) == len(set(raw_paths)), "Raw paths contain duplicates"
assert raw_paths == sorted(raw_paths), "Raw paths must be sorted"
assert len(eligible_paths) == len(set(eligible_paths)), "Eligible paths contain duplicates"
assert eligible_paths == sorted(eligible_paths), "Eligible paths must be sorted"
assert all(path.endswith(".py") for path in raw_paths), "Raw scope must contain only Python files"
assert all(path.endswith(".py") for path in eligible_paths), "Eligible scope must contain only Python files"
assert all('\\' not in path for path in raw_paths), "Paths must use POSIX separators"
assert all(not path.startswith("../") for path in raw_paths), "Paths must stay inside repository root"
assert set(eligible_paths) == set(independent_eligible_paths), "Full manifest must exactly equal eligible set"
assert set(smoke_paths).issubset(set(eligible_paths)), "Smoke scope must be a subset of full eligible scope"

for record in manifest_records:
    assert record["commit_sha"] == commit_hash, "Commit SHA mismatch in manifest"
    assert record["repository_id"] == "huggingface/transformers-pr-agent", "Repo ID mismatch"
    assert record["file_path"].endswith(".py"), "Manifest record is not a Python file"
    assert record["content_sha256"], "Manifest record is missing content hash"

print("Exact set-equality assertion PASSED: full manifest paths == eligible paths")
print("Task 1 verification assertions PASSED successfully!")