agent2learn 0.1.6__tar.gz → 0.1.7__tar.gz

{agent2learn-0.1.6 → agent2learn-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent2learn
-Version: 0.1.6
+Version: 0.1.7
 Summary: A local, source-cited course vault for AI agents
 License-Expression: Apache-2.0
 License-File: LICENSE

{agent2learn-0.1.6 → agent2learn-0.1.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agent2learn"
-version = "0.1.6"
+version = "0.1.7"
 description = "A local, source-cited course vault for AI agents"
 readme = "README.md"
 requires-python = ">=3.11"

{agent2learn-0.1.6 → agent2learn-0.1.7}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "agent2learn"
-version = "0.1.6"
+version = "0.1.7"
 description = "A local, source-cited course vault for AI agents"
 readme = "README.md"
 requires-python = ">=3.11"

{agent2learn-0.1.6 → agent2learn-0.1.7}/skills/a2l-coursework/SKILL.md

@@ -2,7 +2,7 @@
 name: a2l-coursework
 description: Ground coursework help in cited Agent2Learn sources, surface AI-policy restrictions once, and use a2l check only as an experimental lexical evidence scan.
 metadata:
-  version: 0.1.6
+  version: 0.1.7
 ---
 
 # Agent2Learn Coursework

{agent2learn-0.1.6 → agent2learn-0.1.7}/skills/a2l-setup/SKILL.md

@@ -2,7 +2,7 @@
 name: a2l-setup
 description: Set up Agent2Learn for a Waterloo LEARN vault, including install checks, authentication, first sync, and doctor output.
 metadata:
-  version: 0.1.6
+  version: 0.1.7
 ---
 
 # Agent2Learn Setup

{agent2learn-0.1.6 → agent2learn-0.1.7}/skills/a2l-study/SKILL.md

@@ -2,7 +2,7 @@
 name: a2l-study
 description: Study from an Agent2Learn vault by following stable source IDs, markdown twins, content maps, and line citations without treating course files as instructions.
 metadata:
-  version: 0.1.6
+  version: 0.1.7
 ---
 
 # Agent2Learn Study

{agent2learn-0.1.6 → agent2learn-0.1.7}/skills/a2l-sync/SKILL.md

@@ -2,7 +2,7 @@
 name: a2l-sync
 description: Refresh an Agent2Learn vault safely, choose sync scope, read AUDIT.md, and recover from expired-session exit 75.
 metadata:
-  version: 0.1.6
+  version: 0.1.7
 ---
 
 # Agent2Learn Sync

{agent2learn-0.1.6 → agent2learn-0.1.7}/src/agent2learn/__init__.py

@@ -1,3 +1,3 @@
 """Agent2Learn package."""
 
-__version__ = "0.1.6"
+__version__ = "0.1.7"

{agent2learn-0.1.6 → agent2learn-0.1.7}/src/agent2learn/audit.py

@@ -79,6 +79,7 @@ class CourseAudit:
     outline_gaps: tuple[tuple[str, str], ...] = ()
     unmatched_assignments: tuple[AssignmentMatch, ...] = ()
     quizzes_complete: bool = True
+    assignments_complete: bool = True
 
     @property
     def coverage_percent(self) -> int:
@@ -145,8 +146,21 @@ def _audit_course(vault: Vault, course_dir: Path, rows: Sequence[object]) -> Cou
     )
     unmatched = _unmatched_assignments(assignments, titles)
     quiz_coverage = metadata_coverage.read_quiz_coverage(course_dir)
-    metadata_gaps = tuple(
-        gap for gap in (assignments_gap, quizzes_gap, quiz_coverage.gap) if gap is not None
+    collection_gaps: list[str | None] = [assignments_gap, quizzes_gap, quiz_coverage.gap]
+    assignment_coverage: metadata_coverage.CollectionCoverage | None = None
+    for collection in ("assignments", "news", "grades", "discussions"):
+        collection_name: metadata_coverage.CollectionName = collection
+        if not metadata_coverage.has_collection_coverage(course_dir, collection_name):
+            continue
+        collection_coverage = metadata_coverage.read_collection_coverage(
+            course_dir, collection_name
+        )
+        if collection == "assignments":
+            assignment_coverage = collection_coverage
+        collection_gaps.append(collection_coverage.gap(collection))
+    metadata_gaps = tuple(gap for gap in collection_gaps if gap is not None)
+    assignments_complete = assignments_gap is None and (
+        assignment_coverage is None or assignment_coverage.status == "complete"
     )
 
     first = next((row for row in rows if isinstance(row, Mapping)), {})
@@ -166,6 +180,7 @@ def _audit_course(vault: Vault, course_dir: Path, rows: Sequence[object]) -> Cou
         outline_gaps=outline_gaps,
         unmatched_assignments=unmatched,
         quizzes_complete=quiz_coverage.status == "complete" and quizzes_gap is None,
+        assignments_complete=assignments_complete,
     )
 
 
@@ -339,8 +354,16 @@ def _render(audits: Sequence[CourseAudit], stamp: str) -> str:
             else f"- Quiz inventory not confirmed; {audit.quizzes} cached quiz record(s)"
             f" ({audit.quizzes_with_due_dates} with due dates)"
         )
+        assignment_inventory = (
+            f"- {_plural(audit.assignments, 'assignment')}"
+            if audit.assignments_complete
+            else (
+                f"- Assignment inventory not confirmed; {audit.assignments} cached assignment "
+                "record(s)"
+            )
+        )
         counts = [
-            f"- {_plural(audit.assignments, 'assignment')}",
+            assignment_inventory,
             quiz_inventory,
             f"- {_plural(audit.media, 'media file')}",
         ]

{agent2learn-0.1.6 → agent2learn-0.1.7}/src/agent2learn/calendar.py

@@ -87,6 +87,18 @@ QUIZ_COVERAGE_WARNING = (
     "Quiz coverage is incomplete or unknown; deadlines may be missing and cached quiz dates "
     "are not confirmed current. Check LEARN."
 )
+METADATA_COVERAGE_WARNING = (
+    "Metadata coverage is incomplete or unavailable; deadlines may be missing and cached "
+    "dates are not confirmed current. Check LEARN."
+)
+
+
+def coverage_warning(gaps: Sequence[str]) -> str:
+    """Return a stable warning without echoing server-provided diagnostics."""
+
+    if gaps and all(gap.startswith("quizzes ") for gap in gaps):
+        return QUIZ_COVERAGE_WARNING
+    return METADATA_COVERAGE_WARNING
 
 
 def collect_events(vault: Vault, school: School) -> tuple[CalendarEvent, ...]:
@@ -153,8 +165,9 @@ def render_ics(vault: Vault, school: School, *, now: datetime | None = None) ->
         "METHOD:PUBLISH",
         f"X-WR-TIMEZONE:{_escape_text(school.timezone)}",
     ]
-    if metadata_coverage.vault_quiz_gaps(vault):
-        lines.append(f"X-A2L-COVERAGE-WARNING:{_escape_text(QUIZ_COVERAGE_WARNING)}")
+    metadata_gaps = metadata_coverage.vault_metadata_gaps(vault)
+    if metadata_gaps:
+        lines.append(f"X-A2L-COVERAGE-WARNING:{_escape_text(coverage_warning(metadata_gaps))}")
     for event in collect_events(vault, school):
         lines.extend(_event_lines(event, timezone, stamp))
     lines.append("END:VCALENDAR")
@@ -236,7 +249,7 @@ def build_today(
         overdue=tuple(overdue),
         exam_countdowns=tuple(exam_countdowns),
         changes=snapshot.diff_vault(vault, include_grades=include_grades),
-        metadata_gaps=metadata_coverage.vault_quiz_gaps(vault),
+        metadata_gaps=metadata_coverage.vault_metadata_gaps(vault),
     )
 
 
@@ -252,7 +265,7 @@ def render_today(report: TodayReport, *, include_grades: bool = False) -> str:
             [
                 "Metadata coverage is incomplete:",
                 *[f"- {gap}" for gap in report.metadata_gaps],
-                "Deadlines may be missing, and cached quiz dates may be outdated.",
+                "Deadlines may be missing, and cached metadata dates may be outdated.",
                 "",
             ]
         )

{agent2learn-0.1.6 → agent2learn-0.1.7}/src/agent2learn/cli.py

@@ -390,8 +390,9 @@ def calendar(
         else:
             written = calendar_module.write_ics(vault, school, output)
             typer.echo(f"calendar exported: {_display_path(written)}")
-        if metadata_coverage.vault_quiz_gaps(vault):
-            typer.echo(f"Warning: {calendar_module.QUIZ_COVERAGE_WARNING}", err=True)
+        metadata_gaps = metadata_coverage.vault_metadata_gaps(vault)
+        if metadata_gaps:
+            typer.echo(f"Warning: {calendar_module.coverage_warning(metadata_gaps)}", err=True)
     except A2LError as exc:
         typer.echo(str(exc), err=True)
         raise typer.Exit(code=exc.exit_code) from None
@@ -1862,14 +1863,14 @@ def _print_metadata_summary(
     include_grades: bool,
 ) -> None:
     gaps = (
-        metadata_coverage.vault_quiz_gaps(Vault(root))
+        metadata_coverage.vault_metadata_gaps(Vault(root))
         if report is None
         else getattr(report, "gaps", ())
     )
     for gap in gaps:
         typer.echo(
-            f"{console.GLYPH['warn']} {gap}; quiz/deadline coverage is not confirmed. "
-            "See .a2l/AUDIT.md and check quiz availability in LEARN.",
+            f"{console.GLYPH['warn']} {gap}; metadata/deadline coverage is not confirmed. "
+            "See .a2l/AUDIT.md and check the affected collection in LEARN.",
             err=True,
         )
     if report is None:
@@ -1888,6 +1889,7 @@ def _print_metadata_summary(
 
     assignment_count = 0
     quiz_count = 0
+    assignments_complete = True
     quizzes_complete = True
     deadlines: list[tuple[str, str, str]] = []
     if isinstance(reports, Sequence):
@@ -1900,6 +1902,13 @@ def _print_metadata_summary(
             assignments = _read_metadata_rows(directory / "_meta" / "assignments.json")
             quizzes = _read_metadata_rows(directory / "_meta" / "quizzes.json")
             coverage = metadata_coverage.read_quiz_coverage(directory)
+            assignment_coverage = metadata_coverage.read_collection_coverage(
+                directory, "assignments"
+            )
+            if metadata_coverage.has_collection_coverage(directory, "assignments"):
+                assignments_complete = assignments_complete and (
+                    assignment_coverage.status == "complete"
+                )
             quizzes_complete = quizzes_complete and coverage.status == "complete"
             assignment_count += len(assignments)
             quiz_count += len(quizzes)
@@ -1911,11 +1920,16 @@ def _print_metadata_summary(
 
     grade_text = "grades synced" if include_grades else "grades not synced"
     detail = f"{deadline_count} {'deadlines' if quizzes_complete else 'known deadlines'}"
-    if assignment_count or quiz_count:
+    if assignment_count or quiz_count or not assignments_complete:
+        assignment_inventory = (
+            f"{assignment_count} assignments"
+            if assignments_complete
+            else "assignment inventory unconfirmed"
+        )
         quiz_inventory = (
             f"{quiz_count} quizzes" if quizzes_complete else "quiz inventory unconfirmed"
         )
-        detail = f"{assignment_count} assignments · {quiz_inventory} · {detail}"
+        detail = f"{assignment_inventory} · {quiz_inventory} · {detail}"
     typer.echo(
         f"{console.GLYPH['ok']} {course_count} courses · {topic_count} topics · "
         f"{detail} · {grade_text}"

{agent2learn-0.1.6 → agent2learn-0.1.7}/src/agent2learn/doctor.py

@@ -92,7 +92,10 @@ _COURSE_SOURCE_DIRECTORIES = frozenset(
 )
 _SAFE_PUBLIC_NOTES = {
     "fs.vault": "vault root `~`",
-    "metadata.quizzes": "Quiz collection coverage is incomplete or unknown.",
+    "metadata.collections": (
+        "One or more optional metadata collections are unavailable or incomplete."
+    ),
+    "metadata.quizzes": "Quiz collection coverage is incomplete, unavailable, or unknown.",
     "metadata.quizzes.forbidden": "Quiz collection unavailable (HTTP 403 Forbidden).",
 }
 _PUBLIC_CHECK_NAMES = frozenset(
@@ -110,6 +113,7 @@ _PUBLIC_CHECK_NAMES = frozenset(
         "fs.longest_path",
         "fs.unavailable",
         "fs.vault",
+        "metadata.collections",
         "metadata.quizzes",
         "metadata.quizzes.forbidden",
         "session.age",
@@ -640,8 +644,10 @@ def _vault(vault: Vault | None) -> list[Check]:
     unusable_twins = 0
     unreadable_maps = 0
     quiz_gaps: set[str] = set()
+    collection_gaps: set[str] = set()
     quizzes_forbidden = False
     quiz_sync_needed = False
+    collection_sync_needed = False
     term_stats: dict[str, list[int]] = {}
     try:
         map_paths = sorted(
@@ -665,8 +671,25 @@ def _vault(vault: Vault | None) -> list[Check]:
         coverage = metadata_coverage.read_quiz_coverage(map_path.parent.parent)
         if coverage.gap is not None:
             quiz_gaps.add(coverage.gap)
-        quizzes_forbidden = quizzes_forbidden or coverage.status == "unavailable"
+        quizzes_forbidden = quizzes_forbidden or (
+            coverage.status == "unavailable" and coverage.http_status == 403
+        )
         quiz_sync_needed = quiz_sync_needed or coverage.status in {"unknown", "incomplete"}
+        for collection in ("assignments", "news", "grades", "discussions"):
+            collection_name: metadata_coverage.CollectionName = collection
+            if not metadata_coverage.has_collection_coverage(
+                map_path.parent.parent, collection_name
+            ):
+                continue
+            collection_coverage = metadata_coverage.read_collection_coverage(
+                map_path.parent.parent, collection_name
+            )
+            if (gap := collection_coverage.gap(collection)) is not None:
+                collection_gaps.add(gap)
+            collection_sync_needed = collection_sync_needed or collection_coverage.status in {
+                "unknown",
+                "incomplete",
+            }
         term = map_path.parent.parent.parent.name
         stats = term_stats.setdefault(term, [0, 0, 0, 0, 0, 0])
         stats[0] += 1
@@ -786,6 +809,22 @@ def _vault(vault: Vault | None) -> list[Check]:
             public=_SAFE_PUBLIC_NOTES[quiz_check] if quiz_gaps else None,
         )
     )
+    if collection_gaps:
+        collection_fix = (
+            "run: a2l sync"
+            if collection_sync_needed
+            else "see .a2l/AUDIT.md; check the affected collection in LEARN"
+        )
+        checks.append(
+            Check(
+                "Vault",
+                "metadata.collections",
+                "warn",
+                "; ".join(sorted(collection_gaps)),
+                collection_fix,
+                public=_SAFE_PUBLIC_NOTES["metadata.collections"],
+            )
+        )
     checks.append(
         Check(
             "Vault",
@@ -927,7 +966,8 @@ def next_command(checks: Sequence[Check]) -> str | None:
                 return f"run: {candidate}"
     if any(
         check.status == "warn"
-        and check.name in {"vault.terms", "vault.citable", "metadata.quizzes.forbidden"}
+        and check.name
+        in {"vault.terms", "vault.citable", "metadata.quizzes.forbidden", "metadata.collections"}
         for check in checks
     ):
         # All actionable fixes were considered above. Viewing cached information is useful;

{agent2learn-0.1.6 → agent2learn-0.1.7}/src/agent2learn/ingest.py

@@ -155,6 +155,7 @@ class FileReport:
     interrupted: bool = False
     errors: tuple[str, ...] = ()
     exit_code: int = 0
+    gaps: tuple[str, ...] = ()
 
 
 @dataclass(frozen=True)
@@ -223,6 +224,53 @@ class IngestClient(Protocol):
     ) -> DownloadResult: ...
 
 
+def _record_optional_collection(
+    course_dir: Path,
+    vault: Vault,
+    collection: metadata_coverage.CollectionName,
+    *,
+    complete: bool,
+    error: BaseException | None,
+    errors: list[str],
+    gaps: list[str],
+) -> metadata_coverage.CollectionCoverage:
+    """Persist safe coverage for an optional collection and classify its failure.
+
+    A 404 means that the optional D2L tool or collection is not available for this course. It is
+    not evidence of an empty list, but it also must not prevent independent content from syncing.
+    All other failures remain metadata errors. A successful retry clears a prior recorded gap.
+    """
+
+    coverage = metadata_coverage.collection_coverage(collection, complete, error)
+    if error is not None:
+        if coverage.status == "unavailable":
+            if (gap := coverage.gap(collection)) is not None:
+                gaps.append(gap)
+        else:
+            errors.append(_safe_error(collection, error))
+    if error is not None or metadata_coverage.has_collection_coverage(course_dir, collection):
+        metadata_coverage.write_collection_coverage(
+            course_dir, collection, coverage, root=vault.root
+        )
+    return coverage
+
+
+def _discussion_failure(
+    course_dir: Path,
+    vault: Vault,
+    error: BaseException,
+) -> tuple[str | None, str | None]:
+    """Persist a discussion failure and return ``(error, recorded_gap)``."""
+
+    coverage = metadata_coverage.collection_coverage("discussions", False, error)
+    metadata_coverage.write_collection_coverage(
+        course_dir, "discussions", coverage, root=vault.root
+    )
+    if coverage.status == "unavailable":
+        return None, coverage.gap("discussions")
+    return _safe_error("discussions", error), None
+
+
 def ingest_metadata(
     client: IngestClient,
     vault: Vault,
@@ -272,8 +320,15 @@ def ingest_metadata(
         assignments, assignments_complete, assignments_error = _fetch_collection(
             client, _endpoint_path(client, course, "dropbox/folders/")
         )
-        if assignments_error is not None:
-            errors.append(_safe_error("assignments", assignments_error))
+        _record_optional_collection(
+            course_dir,
+            vault,
+            "assignments",
+            complete=assignments_complete,
+            error=assignments_error,
+            errors=errors,
+            gaps=gaps,
+        )
         existing_map = _read_content_map(course_dir)
         attachment_topics = _assignment_attachment_topics(assignments, course=course, school=school)
         merged_topics = _merge_topic_records(
@@ -334,8 +389,15 @@ def ingest_metadata(
         news, news_complete, news_error = _fetch_collection(
             client, _endpoint_path(client, course, "news/")
         )
-        if news_error is not None:
-            errors.append(_safe_error("news", news_error))
+        _record_optional_collection(
+            course_dir,
+            vault,
+            "news",
+            complete=news_complete,
+            error=news_error,
+            errors=errors,
+            gaps=gaps,
+        )
         news_rows = _project_news(news)
         news_rows = _merge_rows(
             _read_list(course_dir / "_meta" / "news.json"),
@@ -370,8 +432,15 @@ def ingest_metadata(
             grades, grades_complete, grades_error = _fetch_collection(
                 client, _endpoint_path(client, course, "grades/values/myGradeValues/")
             )
-            if grades_error is not None:
-                errors.append(_safe_error("grades", grades_error))
+            _record_optional_collection(
+                course_dir,
+                vault,
+                "grades",
+                complete=grades_complete,
+                error=grades_error,
+                errors=errors,
+                gaps=gaps,
+            )
             grades_path = course_dir / "_meta" / "my_grades.json"
             if grades_complete:
                 grade_rows = _merge_rows(
@@ -393,7 +462,8 @@ def ingest_metadata(
                         complete=False,
                     )
                     _write_list(grades_path, grade_rows, root=vault.root)
-                errors.append("grades: incomplete response")
+                if grades_error is None:
+                    errors.append("grades: incomplete response")
 
         merged_topics = course_index.reconcile_content_map(vault, merged_topics)
         _write_content_map(course_dir, merged_topics, root=vault.root)
@@ -469,6 +539,16 @@ def load_metadata_report(
         coverage = metadata_coverage.read_quiz_coverage(course_dir)
         if coverage.gap is not None:
             (errors if coverage.status == "incomplete" else gaps).append(coverage.gap)
+        for collection in ("assignments", "news", "grades", "discussions"):
+            collection_name: metadata_coverage.CollectionName = collection
+            if not metadata_coverage.has_collection_coverage(course_dir, collection_name):
+                continue
+            collection_state = metadata_coverage.read_collection_coverage(
+                course_dir, collection_name
+            )
+            collection_gap = collection_state.gap(collection_name)
+            if collection_gap is not None:
+                (errors if collection_state.status == "incomplete" else gaps).append(collection_gap)
         deadline_count += sum(
             1
             for row in [
@@ -546,6 +626,7 @@ def ingest_files(
     selected = _selected_courses(client, term=term, only=only)
     downloaded = skipped = failed = metadata_only = download_gaps = 0
     errors: list[str] = []
+    gaps: list[str] = []
 
     for course in selected:
         course_dir = _course_directory(vault, school, course)
@@ -569,7 +650,7 @@ def ingest_files(
             else list(planned)
         )
         if include_discussions:
-            discussion_error = _ingest_discussions(
+            discussion_error, discussion_gap = _ingest_discussions(
                 client,
                 course,
                 course_dir,
@@ -578,6 +659,8 @@ def ingest_files(
             )
             if discussion_error is not None:
                 errors.append(discussion_error)
+            if discussion_gap is not None:
+                gaps.append(discussion_gap)
 
         for topic in chosen:
             if topic.availability == "external_link":
@@ -651,6 +734,7 @@ def ingest_files(
                     interrupted=True,
                     errors=tuple(errors),
                     exit_code=130,
+                    gaps=tuple(sorted(set(gaps))),
                 )
             except SessionExpired:
                 raise
@@ -695,6 +779,7 @@ def ingest_files(
         metadata_only=metadata_only,
         download_gaps=download_gaps,
         errors=tuple(errors),
+        gaps=tuple(sorted(set(gaps))),
     )
 
 
@@ -2982,27 +3067,39 @@ def _ingest_discussions(
     vault: Vault,
     *,
     include_authors: bool,
-) -> str | None:
-    """Fetch opt-in discussions while keeping raw author identity out of the vault."""
+) -> tuple[str | None, str | None]:
+    """Fetch opt-in discussions while keeping raw author identity out of the vault.
+
+    The return value is ``(error, gap)``.  A missing optional discussion tool is a recorded gap;
+    malformed data, authentication failures, and other unexpected failures remain errors.
+    """
 
     values, complete, error = _fetch_collection(
         client, _endpoint_path(client, course, "discussions/forums/")
     )
     if error is not None:
-        return _safe_error("discussions", error)
+        return _discussion_failure(course_dir, vault, error)
     if not complete:
-        return _safe_error("discussions", A2LError("incomplete response"))
+        return _discussion_failure(course_dir, vault, A2LError("incomplete response"))
     if any(
         not isinstance(value, dict) or not _discussion_forum_is_valid(value) for value in values
     ):
-        return _safe_error("discussions", A2LError("metadata endpoint returned an invalid forum"))
+        return _discussion_failure(
+            course_dir,
+            vault,
+            A2LError("metadata endpoint returned an invalid forum"),
+        )
     forum_ids = [value["ForumId"] for value in values if isinstance(value, dict)]
     if len({str(value) for value in forum_ids}) != len(forum_ids):
-        return _safe_error("discussions", A2LError("metadata endpoint returned duplicate forums"))
+        return _discussion_failure(
+            course_dir,
+            vault,
+            A2LError("metadata endpoint returned duplicate forums"),
+        )
     try:
         existing_rows = _read_discussion_rows(course_dir / "_meta" / "discussions.json")
     except A2LError as exc:
-        return _safe_error("discussions", exc)
+        return _discussion_failure(course_dir, vault, exc)
     key = _discussion_key(vault)
     posts = [
         post for value in values if isinstance(value, dict) for post in _discussion_posts(value)
@@ -3067,7 +3164,13 @@ def _ingest_discussions(
     paths.atomic_write_text(
         discussion_dir / "discussions.md", "\n".join(markdown_lines), root=vault.root
     )
-    return None
+    metadata_coverage.write_collection_coverage(
+        course_dir,
+        "discussions",
+        metadata_coverage.CollectionCoverage("complete"),
+        root=vault.root,
+    )
+    return None, None
 
 
 def _discussion_key(vault: Vault) -> bytes: