Add automated problem notes workflow

Author: sushildalavi

.github/workflows/update-progress.yml

@@ -1,4 +1,4 @@
-name: Update Progress
+name: Update Progress And Notes
 
 on:
   push:
@@ -23,17 +23,20 @@ jobs:
         with:
           python-version: "3.x"
 
+      - name: Refresh knowledge notes
+        run: python3 scripts/sync_problem_notes.py
+
       - name: Refresh README progress
         run: python3 scripts/update_progress.py
 
-      - name: Commit README updates
+      - name: Commit generated updates
         run: |
-          if git diff --quiet -- README.md; then
-            echo "No README changes to commit."
+          if git diff --quiet -- README.md notes data/problem_metadata.json; then
+            echo "No generated changes to commit."
             exit 0
           fi
           git config user.name "github-actions[bot]"
           git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
-          git add README.md
-          git commit -m "Update DSA progress"
+          git add README.md notes data/problem_metadata.json
+          git commit -m "Update DSA notes and progress"
           git push

README.md

@@ -30,10 +30,34 @@ Tracked unique problems solved across all sheets: `0 / 293`
 
 - Solve on `LeetCode`
 - Let `LeetSync` push the accepted submission into this repository
-- The `Update Progress` GitHub Action scans the synced solution names and refreshes the progress table in this README
+- The GitHub Action scans the synced solution names and refreshes the progress table in this README
+- The same workflow creates or updates per-problem notes in [`notes/problems/`](notes/problems) and refreshes the index at [`notes/INDEX.md`](notes/INDEX.md)
+
+## Knowledge Capture
+
+- Your solution code is saved by `LeetSync`
+- A note stub is generated automatically for each synced problem with:
+  - LeetCode link
+  - difficulty
+  - topic tags
+  - tracked sheet membership
+  - synced solution paths
+- Your personal summary, chosen data structures, and exact approach go into the problem note file
+
+To save your own approach quickly after solving, use:
+
+```bash
+python3 scripts/update_problem_note.py two-sum \
+  --summary "Find two indices whose values add up to the target." \
+  --data-structures "Array, Hash Map" \
+  --approach "Use a one-pass hash map to store seen values and check complements." \
+  --time "O(n)" \
+  --space "O(n)"
+```
 
 ## Notes
 
 - `NeetCode 150` is a subset of `NeetCode 250`, so those counts intentionally overlap
 - `Striver's SDE Sheet` tracking only covers the LeetCode-backed problems from the official sheet
 - If a Striver problem is not solved on LeetCode, `LeetSync` cannot sync it into this repository
+- The repo can save question metadata automatically, but your exact reasoning is only accurate if you add it to the generated note

data/problem_metadata.json

@@ -0,0 +1 @@
+{}

notes/INDEX.md

@@ -0,0 +1,5 @@
+# Problem Notes Index
+
+This index is generated automatically from synced solutions.
+
+No synced solutions detected yet.

scripts/repo_tools.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+TRACKS_PATH = ROOT / "data" / "tracks.json"
+
+TRACK_LABELS = {
+    "neetcode150": "NeetCode 150",
+    "neetcode250": "NeetCode 250",
+    "striverSdeSheetLeetCode": "Striver's SDE Sheet (LeetCode-backed)",
+}
+
+# Striver's sheet still contains a few legacy LeetCode URLs.
+ALIASES = {
+    "coin-change-2": "coin-change-ii",
+    "implement-strstr": "find-the-index-of-the-first-occurrence-in-a-string",
+}
+
+IGNORED_TOP_LEVEL = {
+    ".git",
+    ".github",
+    ".venv",
+    "__pycache__",
+    ".pytest_cache",
+    ".ruff_cache",
+    "data",
+    "notes",
+    "node_modules",
+    "scripts",
+    "venv",
+}
+
+CODE_EXTENSIONS = {
+    ".c",
+    ".cc",
+    ".cpp",
+    ".cs",
+    ".go",
+    ".java",
+    ".js",
+    ".jsx",
+    ".kt",
+    ".kts",
+    ".php",
+    ".py",
+    ".rb",
+    ".rs",
+    ".scala",
+    ".sql",
+    ".swift",
+    ".ts",
+    ".tsx",
+}
+
+
+def normalize_candidate(value: str) -> str:
+    value = value.strip().lower()
+    value = value.replace("_", "-")
+    value = re.sub(r"^\d+[.\-_\s]+", "", value)
+    value = re.sub(r"[^a-z0-9]+", "-", value)
+    value = re.sub(r"-{2,}", "-", value).strip("-")
+    return value
+
+
+def canonical_slug(slug: str) -> str:
+    normalized = normalize_candidate(slug)
+    return ALIASES.get(normalized, normalized)
+
+
+def load_tracks() -> dict[str, list[str]]:
+    raw = json.loads(TRACKS_PATH.read_text())
+    tracks: dict[str, list[str]] = {}
+    for name, slugs in raw.items():
+        deduped: list[str] = []
+        seen: set[str] = set()
+        for slug in slugs:
+            canonical = canonical_slug(slug)
+            if canonical in seen:
+                continue
+            seen.add(canonical)
+            deduped.append(canonical)
+        tracks[name] = deduped
+    return tracks
+
+
+def problem_track_memberships(slug: str, tracks: dict[str, list[str]] | None = None) -> list[str]:
+    tracks = tracks or load_tracks()
+    memberships = [
+        TRACK_LABELS[name]
+        for name, slugs in tracks.items()
+        if slug in slugs
+    ]
+    return memberships or ["General Practice"]
+
+
+def _top_level_problem_entries() -> list[Path]:
+    entries: list[Path] = []
+    for path in sorted(ROOT.iterdir()):
+        if path.name.startswith(".") and path.name not in {".leetcode"}:
+            continue
+        if path.name in IGNORED_TOP_LEVEL:
+            continue
+        if path.is_dir():
+            entries.append(path)
+            continue
+        if path.is_file() and path.suffix.lower() in CODE_EXTENSIONS:
+            entries.append(path)
+    return entries
+
+
+def _solution_files_for_entry(entry: Path) -> list[str]:
+    if entry.is_file():
+        return [str(entry.relative_to(ROOT))]
+
+    solution_paths: list[str] = []
+    for path in sorted(entry.rglob("*")):
+        if not path.is_file():
+            continue
+        if any(part.startswith(".") for part in path.parts):
+            continue
+        if path.suffix.lower() not in CODE_EXTENSIONS:
+            continue
+        solution_paths.append(str(path.relative_to(ROOT)))
+    return solution_paths
+
+
+def discover_problem_solutions() -> dict[str, list[str]]:
+    discovered: dict[str, set[str]] = {}
+    for entry in _top_level_problem_entries():
+        slug_source = entry.stem if entry.is_file() else entry.name
+        slug = canonical_slug(slug_source)
+        if not slug:
+            continue
+        discovered.setdefault(slug, set()).update(_solution_files_for_entry(entry))
+
+    return {slug: sorted(paths) for slug, paths in discovered.items()}
+
+
+def collect_solved_slugs(tracked_slugs: set[str]) -> set[str]:
+    return set(discover_problem_solutions()).intersection(tracked_slugs)