The definitive list of the best of (consumer facing) open source.
Expanded json formatter for more cases
Lucas69d361fc3f56
diff --git a/.github/workflows/format-maintenance.yml b/.github/workflows/format-maintenance.ymlindex 1e8eca3..e965ac9 100644--- a/.github/workflows/format-maintenance.yml+++ b/.github/workflows/format-maintenance.yml@@ -35,6 +35,7 @@ jobs:run: uv run source/maintenance/json_formatter.py- name: Commit and push changes+ if: always()run: |git config --global user.name "github-actions[bot]"git config --global user.email "github-actions[bot]@users.noreply.github.com"diff --git a/core/data/static/applications.json b/core/data/static/applications.jsonindex 04b1973..fc9080e 100644--- a/core/data/static/applications.json+++ b/core/data/static/applications.json@@ -1,7 +1,7 @@{"applications": [{- "name": "Open Intepreter",+ "name": "Open Interpreter","description": "","repo_url": "https://github.com/openinterpreter/openinterpreter","tags": [@@ -8625,11 +8625,10 @@"name": "Zitadel","description": "","repo_url": "https://github.com/zitadel/zitadel",- "tags": [- "web-cloud"- ],+ "tags": [],"platforms": [- "selfhost"+ "selfhost",+ "web-cloud"],"category": "authentication","flags": [],@@ -9327,19 +9326,6 @@"flags": [],"license": ""},- {- "name": "Swing Music",- "description": "",- "repo_url": "https://github.com/swingmx/swingmusic",- "tags": [],- "platforms": [- "cross",- "selfhost"- ],- "category": "audio-player",- "flags": [],- "license": ""- },{"name": "hiSHtory","description": "",@@ -10436,7 +10422,7 @@"description": "","repo_url": "https://github.com/silverstein/minutes","tags": [- "cli-plus"+ "cli-plus"],"platforms": ["cross"@@ -10618,7 +10604,7 @@"description": "","repo_url": "https://github.com/JFreegman/toxic","tags": [- "cli-plus"+ "cli-plus"],"platforms": ["cross"@@ -10683,7 +10669,7 @@"description": "","repo_url": "https://github.com/scdl-org/scdl","tags": [- "cli-plus"+ "cli-plus"],"platforms": ["cross"@@ -10717,4 +10703,4 @@"license": ""}]-}+}\ No newline at end of filediff --git a/core/source/maintenance/json_formatter.py b/core/source/maintenance/json_formatter.pyindex ea1eb66..1d3d528 100644--- a/core/source/maintenance/json_formatter.py+++ b/core/source/maintenance/json_formatter.py@@ -1,59 +1,474 @@+from __future__ import annotations+import json+from pathlib import Path+import sys-with open("data/static/applications.json") as f:- applications = json.load(f)["applications"]+CORE_DIR = Path(__file__).resolve().parents[2]+if str(CORE_DIR) not in sys.path:+ sys.path.insert(0, str(CORE_DIR))-with open("data/static/categories.json") as f:- categories_data = json.load(f)["subcategories"]- valid_categories = {c["id"].lower() for c in categories_data}+from source.utils.path_utils import DYNAMIC_DATA_DIR, MAINTENANCE_DIR, STATIC_DATA_DIR # noqa: E402-with open("data/static/platforms.json") as f:- platforms_data = json.load(f)["platforms"]- valid_platforms = {p["id"].lower() for p in platforms_data}+VALID_FLAGS = {"custom-description", "custom-license", "custom-homepage"}+VALID_ARCHIVE_REASONS = {+ "closed-source",+ "closed source",+ "abandoned",+ "archived",+ "deleted",+}-seen_github = set()-issues_report = []-# Check for formatting issues inside of all data files (static and dynamic)-for app in applications:- app_issues = []+def validate_categories(+ categories_path: Path,+) -> tuple[list[dict], set[str], set[str]]:+ """Validate categories.json for missing fields, duplicate IDs, and relationships."""+ issues: list[dict] = []+ valid_subcategories: set[str] = set()+ valid_categories: set[str] = set()- github_url = app.get("repo_url", "").strip()- if not github_url:- app_issues.append("Missing GitHub URL")- elif github_url in seen_github:- app_issues.append("Duplicate GitHub URL")- else:- seen_github.add(github_url)+ if not categories_path.exists():+ return (+ [{"name": categories_path.name, "issues": ["File not found"]}],+ valid_subcategories,+ valid_categories,+ )- category = app.get("category", "").lower()- if not category:- app_issues.append("Missing category")- elif category not in valid_categories:- app_issues.append(f"Invalid category '{category}'")+ with open(categories_path, "r", encoding="utf-8") as f:+ data = json.load(f)- platforms = [p.lower() for p in app.get("platforms", [])]- if not platforms:- app_issues.append("Missing platform")- else:- invalid_platforms = [p for p in platforms if p not in valid_platforms]- if invalid_platforms:- app_issues.append(f"Invalid platforms: {', '.join(invalid_platforms)}")+ categories = data.get("categories", [])+ subcategories = data.get("subcategories", [])++ seen_cat_ids: set[str] = set()+ for cat in categories:+ cat_issues: list[str] = []+ cat_id = cat.get("id", "").strip().lower()+ cat_name = cat.get("name", "").strip() or cat_id or "Unnamed Category"++ if not cat_id:+ cat_issues.append("Missing category ID")+ elif cat_id in seen_cat_ids:+ cat_issues.append(f"Duplicate category ID '{cat_id}'")+ else:+ seen_cat_ids.add(cat_id)+ valid_categories.add(cat_id)- if app_issues:- issues_report.append(- {"name": app.get("name", "Unnamed Project"), "issues": app_issues}+ if not cat.get("name", "").strip():+ cat_issues.append("Missing category name")++ if cat_issues:+ issues.append({"name": cat_name, "issues": cat_issues})++ seen_subcat_ids: set[str] = set()+ for subcat in subcategories:+ subcat_issues: list[str] = []+ subcat_id = subcat.get("id", "").strip().lower()+ subcat_name = (+ subcat.get("name", "").strip() or subcat_id or "Unnamed Subcategory")-with open("../resources/maintenance/format_maintenance.md", "w") as f:- f.write("# Format Maintenance Report\n\n")- if not issues_report:- f.write("No issues found. All applications are properly formatted.\n")+ if not subcat_id:+ subcat_issues.append("Missing subcategory ID")+ elif subcat_id in seen_subcat_ids:+ subcat_issues.append(f"Duplicate subcategory ID '{subcat_id}'")+ else:+ seen_subcat_ids.add(subcat_id)+ valid_subcategories.add(subcat_id)++ if subcat_id and subcat_id in seen_cat_ids:+ subcat_issues.append(+ f"Subcategory ID '{subcat_id}' conflicts with category ID"+ )++ if not subcat.get("name", "").strip():+ subcat_issues.append("Missing subcategory name")++ parent = subcat.get("parent", "").strip().lower()+ valid_parent_ids = seen_cat_ids | {"other"}+ if not parent:+ subcat_issues.append("Missing parent category")+ elif seen_cat_ids and parent not in valid_parent_ids:+ subcat_issues.append(f"Invalid parent category '{parent}'")++ if subcat_issues:+ issues.append({"name": subcat_name, "issues": subcat_issues})++ return issues, valid_subcategories, valid_categories+++def validate_platforms(platforms_path: Path) -> tuple[list[dict], set[str]]:+ """Validate platforms.json for missing fields and duplicate IDs."""+ issues: list[dict] = []+ valid_platforms: set[str] = set()++ if not platforms_path.exists():+ return (+ [{"name": platforms_path.name, "issues": ["File not found"]}],+ valid_platforms,+ )++ with open(platforms_path, "r", encoding="utf-8") as f:+ data = json.load(f)++ platforms = data.get("platforms", [])+ seen_platforms: set[str] = set()++ for platform in platforms:+ plat_issues: list[str] = []+ p_id = platform.get("id", "").strip().lower()+ p_name = platform.get("name", "").strip() or p_id or "Unnamed Platform"++ if not p_id:+ plat_issues.append("Missing platform ID")+ elif p_id in seen_platforms:+ plat_issues.append(f"Duplicate platform ID '{p_id}'")+ else:+ seen_platforms.add(p_id)+ valid_platforms.add(p_id)++ if not platform.get("name", "").strip():+ plat_issues.append("Missing platform name")++ if plat_issues:+ issues.append({"name": p_name, "issues": plat_issues})++ return issues, valid_platforms+++def validate_tags(tags_path: Path) -> tuple[list[dict], set[str]]:+ """Validate tags.json for missing fields and duplicate IDs."""+ issues: list[dict] = []+ valid_tags: set[str] = set()++ if not tags_path.exists():+ return [{"name": tags_path.name, "issues": ["File not found"]}], valid_tags++ with open(tags_path, "r", encoding="utf-8") as f:+ data = json.load(f)++ attributes = data.get("attributes", [])+ properties = data.get("properties", [])+ all_tags = attributes + properties++ seen_tags: set[str] = set()+ for tag in all_tags:+ tag_issues: list[str] = []+ t_id = tag.get("id", "").strip().lower()+ t_name = tag.get("description", tag.get("name", t_id)) or "Unnamed Tag"++ if not t_id:+ tag_issues.append("Missing tag ID")+ elif t_id in seen_tags:+ tag_issues.append(f"Duplicate tag ID '{t_id}'")+ else:+ seen_tags.add(t_id)+ valid_tags.add(t_id)++ if tag_issues:+ issues.append({"name": t_name, "issues": tag_issues})++ return issues, valid_tags+++def validate_applications(+ applications_path: Path,+ valid_categories: set[str],+ valid_platforms: set[str],+ valid_tags: set[str],+ valid_flags: set[str],+) -> tuple[list[dict], set[str], set[str]]:+ """Validate applications.json for required fields, valid relationships, and duplicates."""+ issues: list[dict] = []+ seen_github: set[str] = set()+ seen_names: set[str] = set()++ if not applications_path.exists():+ return (+ [{"name": applications_path.name, "issues": ["File not found"]}],+ seen_github,+ seen_names,+ )++ with open(applications_path, "r", encoding="utf-8") as f:+ data = json.load(f)++ applications = data.get("applications", [])++ for app in applications:+ app_issues: list[str] = []+ name = app.get("name", "").strip()++ if not name:+ app_issues.append("Missing application name")+ elif name.lower() in seen_names:+ app_issues.append("Duplicate application name")+ else:+ seen_names.add(name.lower())++ github_url = app.get("repo_url", "").strip()+ if not github_url:+ app_issues.append("Missing GitHub URL")+ elif github_url.lower() in seen_github:+ app_issues.append("Duplicate GitHub URL")+ else:+ seen_github.add(github_url.lower())++ category = app.get("category", "").strip().lower()+ if not category:+ app_issues.append("Missing category")+ elif category not in valid_categories:+ app_issues.append(f"Invalid category '{category}'")++ platforms = [str(p).strip().lower() for p in app.get("platforms", [])]+ if not platforms:+ app_issues.append("Missing platform")+ else:+ invalid_platforms = [p for p in platforms if p not in valid_platforms]+ if invalid_platforms:+ app_issues.append(f"Invalid platforms: {', '.join(invalid_platforms)}")+ seen_p: set[str] = set()+ dup_p: list[str] = []+ for p in platforms:+ if p in seen_p and p not in dup_p:+ dup_p.append(p)+ seen_p.add(p)+ if dup_p:+ app_issues.append(f"Duplicate platforms: {', '.join(dup_p)}")++ tags = [str(t).strip().lower() for t in app.get("tags", [])]+ if tags:+ invalid_tags = [t for t in tags if t not in valid_tags]+ if invalid_tags:+ app_issues.append(f"Invalid tags: {', '.join(invalid_tags)}")+ seen_t: set[str] = set()+ dup_t: list[str] = []+ for t in tags:+ if t in seen_t and t not in dup_t:+ dup_t.append(t)+ seen_t.add(t)+ if dup_t:+ app_issues.append(f"Duplicate tags: {', '.join(dup_t)}")++ flags = [str(f).strip().lower() for f in app.get("flags", [])]+ if flags:+ invalid_flags = [f for f in flags if f not in valid_flags]+ if invalid_flags:+ app_issues.append(f"Invalid flags: {', '.join(invalid_flags)}")+ seen_f: set[str] = set()+ dup_f: list[str] = []+ for f in flags:+ if f in seen_f and f not in dup_f:+ dup_f.append(f)+ seen_f.add(f)+ if dup_f:+ app_issues.append(f"Duplicate flags: {', '.join(dup_f)}")++ if app_issues:+ issues.append(+ {"name": name or "Unnamed Project", "issues": app_issues}+ )++ return issues, seen_github, seen_names+++def validate_backlog(backlog_path: Path) -> list[dict]:+ """Validate backlog.json for missing fields and duplicates."""+ issues: list[dict] = []+ seen_github: set[str] = set()+ seen_names: set[str] = set()++ if not backlog_path.exists():+ return [{"name": backlog_path.name, "issues": ["File not found"]}]++ with open(backlog_path, "r", encoding="utf-8") as f:+ data = json.load(f)++ applications = data.get("applications", [])++ for app in applications:+ app_issues: list[str] = []+ name = app.get("name", "").strip()++ if not name:+ app_issues.append("Missing application name")+ elif name.lower() in seen_names:+ app_issues.append("Duplicate application name")+ else:+ seen_names.add(name.lower())++ github_url = app.get("repo_url", "").strip()+ if not github_url:+ app_issues.append("Missing GitHub URL")+ elif github_url.lower() in seen_github:+ app_issues.append("Duplicate GitHub URL")+ else:+ seen_github.add(github_url.lower())++ if app_issues:+ issues.append(+ {"name": name or "Unnamed Project", "issues": app_issues}+ )++ return issues+++def validate_archive(+ archive_path: Path,+ valid_reasons: set[str],+ active_app_urls: set[str],+) -> list[dict]:+ """Validate archive.json for missing fields, invalid reasons, and duplicates."""+ issues: list[dict] = []+ seen_github: set[str] = set()+ seen_names: set[str] = set()++ if not archive_path.exists():+ return [{"name": archive_path.name, "issues": ["File not found"]}]++ with open(archive_path, "r", encoding="utf-8") as f:+ data = json.load(f)++ applications = data.get("applications", [])++ for app in applications:+ app_issues: list[str] = []+ name = app.get("name", "").strip()++ if not name:+ app_issues.append("Missing application name")+ elif name.lower() in seen_names:+ app_issues.append("Duplicate application name")+ else:+ seen_names.add(name.lower())++ github_url = app.get("repo_url", "").strip()+ if not github_url:+ app_issues.append("Missing GitHub URL")+ elif github_url.lower() in seen_github:+ app_issues.append("Duplicate GitHub URL")+ else:+ seen_github.add(github_url.lower())++ reason = app.get("reason", "").strip().lower()+ if not reason:+ app_issues.append("Missing archive reason")+ elif reason not in valid_reasons:+ app_issues.append(f"Invalid archive reason '{reason}'")++ if github_url and github_url.lower() in active_app_urls:+ app_issues.append("Archived project still present in applications.json")++ if app_issues:+ issues.append(+ {"name": name or "Unnamed Project", "issues": app_issues}+ )++ return issues+++def generate_report(+ output_path: Path,+ report_data: dict[str, list[dict]],+) -> int:+ """Write the markdown report and return the total number of issues found."""+ total_issues = sum(+ len(entry["issues"])+ for entries in report_data.values()+ for entry in entries+ )++ output_path.parent.mkdir(parents=True, exist_ok=True)+ with open(output_path, "w", encoding="utf-8") as f:+ f.write("# Format Maintenance Report\n\n")+ if total_issues == 0:+ f.write("No issues found. All data files are properly formatted.\n")+ else:+ for file_name, entries in report_data.items():+ if not entries:+ continue+ f.write(f"## {file_name}\n\n")+ for entry in entries:+ f.write(f"### {entry['name']}\n")+ for issue in entry["issues"]:+ f.write(f"- {issue}\n")+ f.write("\n")++ return total_issues+++def run_format_checks(+ static_data_dir: Path | str | None = None,+ dynamic_data_dir: Path | str | None = None,+ report_output_file: Path | str | None = None,+) -> tuple[dict[str, list[dict]], int, Path]:+ """Execute all formatting and consistency checks across data files."""+ if static_data_dir is None:+ static_dir = Path("data/static")+ if not static_dir.exists():+ static_dir = STATIC_DATA_DIR+ else:+ static_dir = Path(static_data_dir)++ if dynamic_data_dir is None:+ dynamic_dir = Path("data/dynamic")+ if not dynamic_dir.exists():+ dynamic_dir = DYNAMIC_DATA_DIRelse:- for entry in issues_report:- f.write(f"## {entry['name']}\n")- for issue in entry["issues"]:- f.write(f"- {issue}\n")- f.write("\n")+ dynamic_dir = Path(dynamic_data_dir)++ if report_output_file is None:+ report_path = Path("../resources/maintenance/format_maintenance.md")+ if not report_path.parent.exists():+ report_path = MAINTENANCE_DIR / "format_maintenance.md"+ else:+ report_path = Path(report_output_file)++ cat_issues, valid_subcats, _ = validate_categories(+ static_dir / "categories.json"+ )+ plat_issues, valid_plats = validate_platforms(static_dir / "platforms.json")+ tag_issues, valid_tags = validate_tags(static_dir / "tags.json")++ app_issues, seen_app_urls, _ = validate_applications(+ applications_path=static_dir / "applications.json",+ valid_categories=valid_subcats,+ valid_platforms=valid_plats,+ valid_tags=valid_tags,+ valid_flags=VALID_FLAGS,+ )++ backlog_issues = validate_backlog(static_dir / "backlog.json")+ archive_issues = validate_archive(+ archive_path=dynamic_dir / "archive.json",+ valid_reasons=VALID_ARCHIVE_REASONS,+ active_app_urls=seen_app_urls,+ )++ report_data = {+ "applications.json": app_issues,+ "categories.json": cat_issues,+ "platforms.json": plat_issues,+ "tags.json": tag_issues,+ "backlog.json": backlog_issues,+ "archive.json": archive_issues,+ }++ total_issues = generate_report(report_path, report_data)+ return report_data, total_issues, report_path+++def main() -> None:+ _, total_issues, _ = run_format_checks()+ print("Maintenance report generated: format_maintenance.md")+ if total_issues > 0:+ print(f"Validation failed: {total_issues} issue(s) found.")+ sys.exit(1)+ print("Validation passed: No issues found.")+ sys.exit(0)+++if __name__ == "__main__":+ main()-print("Maintenance report generated: format_maintenance.md")diff --git a/core/tests/test_json_formatter.py b/core/tests/test_json_formatter.pynew file mode 100644index 0000000..bb17b64--- /dev/null+++ b/core/tests/test_json_formatter.py@@ -0,0 +1,310 @@+from __future__ import annotations++import json+from pathlib import Path+import sys+import tempfile+import unittest++CORE_DIR = Path(__file__).resolve().parents[1]+if str(CORE_DIR) not in sys.path:+ sys.path.insert(0, str(CORE_DIR))++from source.maintenance.json_formatter import ( # noqa: E402+ VALID_ARCHIVE_REASONS,+ VALID_FLAGS,+ generate_report,+ run_format_checks,+ validate_applications,+ validate_archive,+ validate_backlog,+ validate_categories,+ validate_platforms,+ validate_tags,+)+++class TestJsonFormatter(unittest.TestCase):+ def setUp(self):+ self.temp_dir = tempfile.TemporaryDirectory()+ self.temp_path = Path(self.temp_dir.name)++ def tearDown(self):+ self.temp_dir.cleanup()++ def test_validate_categories_duplicates_and_parents(self):+ cat_file = self.temp_path / "categories.json"+ cat_file.write_text(+ json.dumps(+ {+ "categories": [+ {"name": "Dev", "id": "dev"},+ {"name": "Dev Dup", "id": "dev"},+ ],+ "subcategories": [+ {"name": "Editor", "id": "editor", "parent": "dev"},+ {"name": "Editor Dup", "id": "editor", "parent": "dev"},+ {"name": "Conflict", "id": "dev", "parent": "dev"},+ {"name": "Invalid Parent", "id": "term", "parent": "nonexistent"},+ ],+ }+ ),+ encoding="utf-8",+ )++ issues, valid_subcats, valid_cats = validate_categories(cat_file)+ issues_flat = [issue for entry in issues for issue in entry["issues"]]++ self.assertIn("Duplicate category ID 'dev'", issues_flat)+ self.assertIn("Duplicate subcategory ID 'editor'", issues_flat)+ self.assertIn("Subcategory ID 'dev' conflicts with category ID", issues_flat)+ self.assertIn("Invalid parent category 'nonexistent'", issues_flat)+ self.assertIn("editor", valid_subcats)+ self.assertIn("dev", valid_cats)++ def test_validate_platforms(self):+ plat_file = self.temp_path / "platforms.json"+ plat_file.write_text(+ json.dumps(+ {+ "platforms": [+ {"name": "Cross", "id": "cross"},+ {"name": "Cross Dup", "id": "cross"},+ ]+ }+ ),+ encoding="utf-8",+ )++ issues, valid_platforms = validate_platforms(plat_file)+ issues_flat = [issue for entry in issues for issue in entry["issues"]]++ self.assertIn("Duplicate platform ID 'cross'", issues_flat)+ self.assertEqual(valid_platforms, {"cross"})++ def test_validate_tags(self):+ tag_file = self.temp_path / "tags.json"+ tag_file.write_text(+ json.dumps(+ {+ "attributes": [+ {"id": "ai", "description": "AI Usage"},+ {"id": "ai", "description": "Duplicate AI"},+ ],+ "properties": [+ {"id": "cli", "name": "CLI"},+ ],+ }+ ),+ encoding="utf-8",+ )++ issues, valid_tags = validate_tags(tag_file)+ issues_flat = [issue for entry in issues for issue in entry["issues"]]++ self.assertIn("Duplicate tag ID 'ai'", issues_flat)+ self.assertEqual(valid_tags, {"ai", "cli"})++ def test_validate_flags_and_tags_in_applications(self):+ app_file = self.temp_path / "applications.json"+ app_file.write_text(+ json.dumps(+ {+ "applications": [+ {+ "name": "App 1",+ "repo_url": "https://github.com/org/app1",+ "category": "editor",+ "platforms": ["cross"],+ "tags": ["ai", "unknown-tag"],+ "flags": ["custom-homepage", "invalid-flag"],+ },+ {+ "name": "App 1", # duplicate name+ "repo_url": "https://github.com/org/app2",+ "category": "editor",+ "platforms": ["cross"],+ "tags": ["cli"],+ "flags": ["custom-license"],+ },+ {+ "name": "App 3",+ "repo_url": "https://github.com/org/app1", # duplicate repo_url+ "category": "invalid-cat",+ "platforms": ["invalid-plat"],+ "tags": [],+ "flags": [],+ },+ ]+ }+ ),+ encoding="utf-8",+ )++ issues, seen_urls, seen_names = validate_applications(+ applications_path=app_file,+ valid_categories={"editor"},+ valid_platforms={"cross"},+ valid_tags={"ai", "cli"},+ valid_flags=VALID_FLAGS,+ )++ first_app_issues = issues[0]["issues"]+ second_app_issues = issues[1]["issues"]+ third_app_issues = issues[2]["issues"]++ self.assertEqual(issues[0]["name"], "App 1")+ self.assertIn("Invalid tags: unknown-tag", first_app_issues)+ self.assertIn("Invalid flags: invalid-flag", first_app_issues)++ # Second App 1 has duplicate name+ self.assertEqual(issues[1]["name"], "App 1")+ self.assertIn("Duplicate application name", second_app_issues)++ # App 3 has duplicate url, invalid category, invalid platform+ self.assertEqual(issues[2]["name"], "App 3")+ self.assertIn("Duplicate GitHub URL", third_app_issues)+ self.assertIn("Invalid category 'invalid-cat'", third_app_issues)+ self.assertIn("Invalid platforms: invalid-plat", third_app_issues)++ def test_validate_backlog(self):+ backlog_file = self.temp_path / "backlog.json"+ backlog_file.write_text(+ json.dumps(+ {+ "applications": [+ {"name": "Backlog 1", "repo_url": "https://github.com/org/b1"},+ {"name": "Backlog 1", "repo_url": "https://github.com/org/b2"},+ {"name": "Backlog 2", "repo_url": "https://github.com/org/b1"},+ ]+ }+ ),+ encoding="utf-8",+ )++ issues = validate_backlog(backlog_file)+ issues_flat = [issue for entry in issues for issue in entry["issues"]]++ self.assertIn("Duplicate application name", issues_flat)+ self.assertIn("Duplicate GitHub URL", issues_flat)++ def test_validate_archive(self):+ archive_file = self.temp_path / "archive.json"+ archive_file.write_text(+ json.dumps(+ {+ "applications": [+ {+ "name": "Archive 1",+ "repo_url": "https://github.com/org/a1",+ "reason": "abandoned",+ },+ {+ "name": "Archive 1",+ "repo_url": "https://github.com/org/a2",+ "reason": "invalid-reason",+ },+ {+ "name": "Active in Apps",+ "repo_url": "https://github.com/org/active",+ "reason": "closed-source",+ },+ ]+ }+ ),+ encoding="utf-8",+ )++ issues = validate_archive(+ archive_path=archive_file,+ valid_reasons=VALID_ARCHIVE_REASONS,+ active_app_urls={"https://github.com/org/active"},+ )+ issues_flat = [issue for entry in issues for issue in entry["issues"]]++ self.assertIn("Duplicate application name", issues_flat)+ self.assertIn("Invalid archive reason 'invalid-reason'", issues_flat)+ self.assertIn(+ "Archived project still present in applications.json", issues_flat+ )++ def test_generate_report_clean_and_with_issues(self):+ report_file = self.temp_path / "report.md"++ # Clean report+ total = generate_report(report_file, {"applications.json": []})+ self.assertEqual(total, 0)+ content = report_file.read_text(encoding="utf-8")+ self.assertIn("No issues found. All data files are properly formatted.", content)++ # Report with issues+ total = generate_report(+ report_file,+ {+ "applications.json": [+ {"name": "App 1", "issues": ["Duplicate application name"]}+ ]+ },+ )+ self.assertEqual(total, 1)+ content = report_file.read_text(encoding="utf-8")+ self.assertIn("## applications.json", content)+ self.assertIn("### App 1", content)+ self.assertIn("- Duplicate application name", content)++ def test_run_format_checks_integration(self):+ static_dir = self.temp_path / "static"+ dynamic_dir = self.temp_path / "dynamic"+ static_dir.mkdir()+ dynamic_dir.mkdir()++ (static_dir / "categories.json").write_text(+ json.dumps({"categories": [{"id": "c1", "name": "C1"}], "subcategories": [{"id": "s1", "name": "S1", "parent": "c1"}]}),+ encoding="utf-8",+ )+ (static_dir / "platforms.json").write_text(+ json.dumps({"platforms": [{"id": "p1", "name": "P1"}]}),+ encoding="utf-8",+ )+ (static_dir / "tags.json").write_text(+ json.dumps({"attributes": [{"id": "t1"}], "properties": []}),+ encoding="utf-8",+ )+ (static_dir / "applications.json").write_text(+ json.dumps({+ "applications": [+ {+ "name": "App Clean",+ "repo_url": "https://github.com/org/clean",+ "category": "s1",+ "platforms": ["p1"],+ "tags": ["t1"],+ "flags": ["custom-description"],+ }+ ]+ }),+ encoding="utf-8",+ )+ (static_dir / "backlog.json").write_text(+ json.dumps({"applications": []}),+ encoding="utf-8",+ )+ (dynamic_dir / "archive.json").write_text(+ json.dumps({"applications": []}),+ encoding="utf-8",+ )++ report_file = self.temp_path / "format_maintenance.md"+ report_data, total_issues, out_path = run_format_checks(+ static_data_dir=static_dir,+ dynamic_data_dir=dynamic_dir,+ report_output_file=report_file,+ )++ self.assertEqual(total_issues, 0)+ self.assertEqual(out_path, report_file)+ self.assertIn("No issues found", report_file.read_text(encoding="utf-8"))+++if __name__ == "__main__":+ unittest.main()diff --git a/resources/maintenance/format_maintenance.md b/resources/maintenance/format_maintenance.mdindex 63132e9..fab8755 100644--- a/resources/maintenance/format_maintenance.md+++ b/resources/maintenance/format_maintenance.md@@ -1,5 +1,24 @@# Format Maintenance Report-## Swing Music+## applications.json++### Tabby+- Duplicate application name++### Zen+- Duplicate application name++### quill+- Duplicate application name++## categories.json++### Time Management+- Duplicate subcategory ID 'time-management'++## archive.json++### Maestral+- Duplicate application name- Duplicate GitHub URL