Skip to content

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.yml
index 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.json
index 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 file
diff --git a/core/source/maintenance/json_formatter.py b/core/source/maintenance/json_formatter.py
index 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_DIR
else:
- 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.py
new file mode 100644
index 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.md
index 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