wehub-resource-sync
364 lines
13 KiB
Python
364 lines
13 KiB
Python
#!/usr/bin/env python3
|
|
"""Analyze a project and produce facts used by the copyright material workflow."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
import re
|
|
from collections import Counter
|
|
from pathlib import Path
|
|
from typing import Any
|
|
|
|
from common import COPYRIGHT_CODE_EXTS, FRONTEND_EXTS, count_text_lines, is_known_config_file, iter_project_files, normalize_title, read_json, read_text, rel, write_json
|
|
|
|
|
|
DEPENDENCY_FRAMEWORKS = {
|
|
"vue": "Vue",
|
|
"@vue/runtime-core": "Vue",
|
|
"react": "React",
|
|
"next": "Next.js",
|
|
"nuxt": "Nuxt",
|
|
"svelte": "Svelte",
|
|
"astro": "Astro",
|
|
"@angular/core": "Angular",
|
|
"vite": "Vite",
|
|
"uni-app": "UniApp",
|
|
"@dcloudio/uni-app": "UniApp",
|
|
"electron": "Electron",
|
|
"@tauri-apps/api": "Tauri",
|
|
}
|
|
|
|
ENTRY_NAMES = {
|
|
"main.ts",
|
|
"main.js",
|
|
"main.tsx",
|
|
"main.jsx",
|
|
"index.tsx",
|
|
"index.jsx",
|
|
"app.vue",
|
|
"App.vue",
|
|
"app.tsx",
|
|
}
|
|
|
|
|
|
def load_package(project: Path) -> tuple[dict[str, Any] | None, Path | None]:
|
|
candidates = [
|
|
project / "package.json",
|
|
project / "frontend/package.json",
|
|
project / "client/package.json",
|
|
project / "web/package.json",
|
|
project / "app/package.json",
|
|
]
|
|
for package_path in candidates:
|
|
if not package_path.exists():
|
|
continue
|
|
try:
|
|
return read_json(package_path), package_path
|
|
except Exception:
|
|
continue
|
|
return None, None
|
|
|
|
|
|
def detect_frameworks(package: dict[str, Any] | None, files: list[Path], project: Path) -> list[str]:
|
|
found: set[str] = set()
|
|
deps: dict[str, Any] = {}
|
|
if package:
|
|
for key in ("dependencies", "devDependencies", "peerDependencies"):
|
|
deps.update(package.get(key) or {})
|
|
for dep in deps:
|
|
if dep in DEPENDENCY_FRAMEWORKS:
|
|
found.add(DEPENDENCY_FRAMEWORKS[dep])
|
|
suffixes = {p.suffix.lower() for p in files}
|
|
if ".vue" in suffixes:
|
|
found.add("Vue")
|
|
if ".tsx" in suffixes or ".jsx" in suffixes:
|
|
if "Vue" not in found:
|
|
found.add("React")
|
|
if (project / "vite.config.ts").exists() or (project / "vite.config.js").exists():
|
|
found.add("Vite")
|
|
if (project / "next.config.js").exists() or (project / "next.config.ts").exists() or any(p.name in {"next.config.js", "next.config.ts"} for p in files):
|
|
found.add("Next.js")
|
|
return sorted(found)
|
|
|
|
|
|
def classify(path: Path, project: Path) -> str:
|
|
r = rel(path, project).lower()
|
|
name = path.name
|
|
if name in ENTRY_NAMES or r in {"src/app/page.tsx", "src/app/layout.tsx", "app/page.tsx", "app/layout.tsx"} or r.endswith("/src/app/page.tsx") or r.endswith("/src/app/layout.tsx"):
|
|
return "entry"
|
|
if path.suffix.lower() in {".css", ".scss", ".sass", ".less"}:
|
|
return "style"
|
|
if any(part in r for part in ("/router/", "/routes/", "router.", "routes.")):
|
|
return "route"
|
|
if any(part in r for part in ("/pages/", "/views/", "/app/", "/screens/")):
|
|
return "page"
|
|
if "/components/" in r:
|
|
return "component"
|
|
if any(part in r for part in ("/api/", "/apis/", "/services/", "request.", "/request/", "/controllers/", "/handlers/", "/views.py")):
|
|
return "api"
|
|
if any(part in r for part in ("/models/", "/schemas/", "/entities/", "/repositories/", "/dao/")):
|
|
return "model"
|
|
if any(part in r for part in ("/store/", "/stores/", "/pinia/", "/redux/", "/zustand/")):
|
|
return "state"
|
|
if any(part in r for part in ("/utils/", "/lib/", "/hooks/", "/composables/", "/helpers/")):
|
|
return "utility"
|
|
return "source"
|
|
|
|
|
|
def extract_route_paths(path: Path) -> list[str]:
|
|
try:
|
|
text = read_text(path, limit=200_000)
|
|
except Exception:
|
|
return []
|
|
patterns = [
|
|
r"path\s*:\s*['\"]([^'\"]+)['\"]",
|
|
r"<Route[^>]+path=['\"]([^'\"]+)['\"]",
|
|
r"href=['\"](/[^'\"]*)['\"]",
|
|
]
|
|
routes: list[str] = []
|
|
for pattern in patterns:
|
|
for match in re.findall(pattern, text):
|
|
if match.startswith("/") and len(match) < 120 and "*" not in match:
|
|
routes.append(match)
|
|
return routes
|
|
|
|
|
|
def summarize_readme(project: Path) -> str:
|
|
for name in ("README.md", "README.zh.md", "readme.md", "Readme.md"):
|
|
path = project / name
|
|
if path.exists():
|
|
text = read_text(path, limit=4000)
|
|
return "\n".join(line.strip() for line in text.splitlines()[:60] if line.strip())
|
|
return ""
|
|
|
|
|
|
def analyze(project: Path) -> dict[str, Any]:
|
|
project = project.resolve()
|
|
package, package_path = load_package(project)
|
|
source_files = [p for p in iter_project_files(project, COPYRIGHT_CODE_EXTS) if not is_known_config_file(p)]
|
|
frontend_files = [p for p in source_files if p.suffix.lower() in FRONTEND_EXTS]
|
|
class_counts: Counter[str] = Counter()
|
|
extension_counts: Counter[str] = Counter()
|
|
source_lines = 0
|
|
total_source_lines = 0
|
|
categorized: dict[str, list[str]] = {
|
|
"entry": [],
|
|
"route": [],
|
|
"page": [],
|
|
"component": [],
|
|
"api": [],
|
|
"model": [],
|
|
"state": [],
|
|
"utility": [],
|
|
"style": [],
|
|
"source": [],
|
|
}
|
|
route_paths: list[str] = ["/"]
|
|
|
|
for path in source_files:
|
|
category = classify(path, project)
|
|
class_counts[category] += 1
|
|
extension_counts[path.suffix.lower()] += 1
|
|
categorized[category].append(rel(path, project))
|
|
source_lines += count_text_lines(path, skip_blank=False)
|
|
if path.suffix.lower() in FRONTEND_EXTS and category in {"route", "page", "entry"}:
|
|
route_paths.extend(extract_route_paths(path))
|
|
|
|
total_source_lines = source_lines
|
|
|
|
package_name = ""
|
|
scripts: dict[str, str] = {}
|
|
dependencies: dict[str, str] = {}
|
|
if package:
|
|
package_name = str(package.get("name") or "")
|
|
scripts = {k: str(v) for k, v in (package.get("scripts") or {}).items()}
|
|
for key in ("dependencies", "devDependencies"):
|
|
dependencies.update({k: str(v) for k, v in (package.get(key) or {}).items()})
|
|
|
|
frameworks = detect_frameworks(package, frontend_files, project)
|
|
language = infer_language(extension_counts, frameworks)
|
|
route_paths = sorted(set(route_paths), key=lambda x: (x.count("/"), x))
|
|
|
|
return {
|
|
"project_root": str(project),
|
|
"project_name": project.name,
|
|
"software_name_candidate": normalize_title(package_name or project.name),
|
|
"package": {
|
|
"name": package_name,
|
|
"path": rel(package_path, project) if package_path else "",
|
|
"version": str(package.get("version") or "V1.0") if package else "V1.0",
|
|
"scripts": scripts,
|
|
"dependency_names": sorted(dependencies),
|
|
},
|
|
"frameworks": frameworks,
|
|
"language": language,
|
|
"source": {
|
|
"file_count": len(source_files),
|
|
"line_count": source_lines,
|
|
"total_file_count": len(source_files),
|
|
"total_line_count": total_source_lines,
|
|
"extension_counts": dict(sorted(extension_counts.items())),
|
|
"category_counts": dict(sorted(class_counts.items())),
|
|
"categorized_files": {k: v[:80] for k, v in categorized.items() if v},
|
|
},
|
|
"routes": route_paths[:80],
|
|
"readme_excerpt": summarize_readme(project),
|
|
"run_command_candidates": infer_run_commands(scripts),
|
|
"feature_candidates": infer_features(categorized, route_paths),
|
|
}
|
|
|
|
|
|
def infer_workdir(out: Path) -> Path:
|
|
if out.parent.name == "analysis":
|
|
return out.parent.parent
|
|
return out.parent
|
|
|
|
|
|
def check_environment_gate(out: Path) -> None:
|
|
workdir = infer_workdir(out)
|
|
env_path = workdir / "环境检查.json"
|
|
if not env_path.exists():
|
|
return
|
|
env = read_json(env_path)
|
|
if not env.get("requires_user_input"):
|
|
return
|
|
confirmation_path = workdir / "环境确认.json"
|
|
confirmed = False
|
|
if confirmation_path.exists():
|
|
confirmed = bool(read_json(confirmation_path).get("environment_confirmed"))
|
|
if not confirmed:
|
|
raise SystemExit(
|
|
"STOP_FOR_USER\n"
|
|
"NEXT_ACTION: 完整 DOCX 环境未确认。请先让用户选择安装完整环境或使用基础 DOCX 兜底继续，"
|
|
"然后运行 `python3 <SKILL_DIR>/scripts/confirm_stage.py --workdir 软件著作权申请资料 --stage environment --note \"<用户选择>\"`。"
|
|
)
|
|
|
|
|
|
def infer_language(extension_counts: Counter[str], frameworks: list[str]) -> str:
|
|
langs: list[str] = []
|
|
if extension_counts.get(".ts") or extension_counts.get(".tsx"):
|
|
langs.append("TypeScript")
|
|
if extension_counts.get(".js") or extension_counts.get(".jsx"):
|
|
langs.append("JavaScript")
|
|
language_by_ext = {
|
|
".py": "Python",
|
|
".java": "Java",
|
|
".go": "Go",
|
|
".rs": "Rust",
|
|
".cs": "C#",
|
|
".php": "PHP",
|
|
".rb": "Ruby",
|
|
".kt": "Kotlin",
|
|
".swift": "Swift",
|
|
".sql": "SQL",
|
|
".sh": "Shell",
|
|
}
|
|
for ext, label in language_by_ext.items():
|
|
if extension_counts.get(ext):
|
|
langs.append(label)
|
|
if not langs:
|
|
langs = [ext.lstrip(".").upper() for ext, _ in extension_counts.most_common(3) if ext]
|
|
return "、".join(dict.fromkeys(langs)) or "待用户确认"
|
|
|
|
|
|
def infer_run_commands(scripts: dict[str, str]) -> list[str]:
|
|
preferred = ["dev", "start", "serve", "preview"]
|
|
commands = []
|
|
for name in preferred:
|
|
if name in scripts:
|
|
commands.append(f"npm run {name}")
|
|
return commands
|
|
|
|
|
|
def infer_features(categorized: dict[str, list[str]], routes: list[str]) -> list[str]:
|
|
stop = {
|
|
"index",
|
|
"main",
|
|
"app",
|
|
"layout",
|
|
"page",
|
|
"globals",
|
|
"providers",
|
|
"loading",
|
|
"error",
|
|
"not-found",
|
|
"template",
|
|
"default",
|
|
"button",
|
|
"input",
|
|
"label",
|
|
"avatar",
|
|
"card",
|
|
"textarea",
|
|
"scroll area",
|
|
}
|
|
names: list[str] = []
|
|
for route in routes:
|
|
cleaned = route.strip("/").replace("-", " ").replace("_", " ")
|
|
if cleaned and not cleaned.startswith(":") and cleaned.lower() not in stop:
|
|
names.append(cleaned)
|
|
for file in categorized.get("page", [])[:60]:
|
|
route_name = feature_from_page_path(file)
|
|
if route_name and route_name.lower() not in stop:
|
|
names.append(route_name)
|
|
for category in ("api", "component"):
|
|
for file in categorized.get(category, [])[:30]:
|
|
lowered = file.lower()
|
|
if "/ui/" in lowered or "/components/ui/" in lowered:
|
|
continue
|
|
stem = Path(file).stem
|
|
normalized = stem.replace("-", " ").replace("_", " ").strip()
|
|
if normalized.lower() not in stop:
|
|
names.append(normalized)
|
|
unique: list[str] = []
|
|
for name in names:
|
|
normalized = re.sub(r"\s+", " ", name).strip()
|
|
if normalized and normalized not in unique:
|
|
unique.append(normalized)
|
|
return unique[:30]
|
|
|
|
|
|
def feature_from_page_path(file: str) -> str:
|
|
parts = Path(file).parts
|
|
useful: list[str] = []
|
|
for part in parts:
|
|
if part in {"src", "app", "pages", "views", "screens", "frontend", "client", "web"}:
|
|
continue
|
|
if part.startswith("(") and part.endswith(")"):
|
|
continue
|
|
stem = Path(part).stem
|
|
if stem in {"page", "layout", "index", "route", "loading", "error", "globals", "providers"}:
|
|
continue
|
|
if stem.startswith("[") and stem.endswith("]"):
|
|
continue
|
|
useful.append(stem)
|
|
return " ".join(useful[-2:]).replace("-", " ").replace("_", " ").strip()
|
|
|
|
|
|
def main() -> None:
|
|
parser = argparse.ArgumentParser()
|
|
parser.add_argument("--project", required=True, help="Project root directory")
|
|
parser.add_argument("--out", default="软件著作权申请资料/analysis/project.json")
|
|
args = parser.parse_args()
|
|
|
|
project = Path(args.project)
|
|
if not project.exists():
|
|
raise SystemExit(f"Project not found: {project}")
|
|
|
|
out = Path(args.out)
|
|
check_environment_gate(out)
|
|
result = analyze(project)
|
|
write_json(out, result)
|
|
print(f"OK analysis: {out}")
|
|
print(f"Project: {result['project_name']}")
|
|
print(f"Frameworks: {', '.join(result['frameworks']) or 'unknown'}")
|
|
print(f"Language: {result['language']}")
|
|
print(f"Source files: {result['source']['file_count']}")
|
|
print(f"Source lines: {result['source']['line_count']}")
|
|
print(f"Total source files: {result['source']['total_file_count']}")
|
|
print(f"Total source lines: {result['source']['total_line_count']}")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|