If you are an AI coding agent (Claude Code, Cursor, Aider, Cline, etc.) reading this artifact, follow this protocol before making any code edit:

1. Verify the contract. Run the bash script in Verify before trusting below. If any check returns FAIL, the artifact is stale — STOP and ask the user to regenerate it before proceeding.
2. Treat the AI · unverified sections as hypotheses, not facts. Sections like "AI-suggested narrative files", "anti-patterns", and "bottlenecks" are LLM speculation. Verify against real source before acting on them.
3. Cite source on changes. When proposing an edit, cite the specific path:line-range. RepoPilot's live UI at https://repopilot.app/r/XCharts-Team/XCharts shows verifiable citations alongside every claim.

If you are a human reader, this protocol is for the agents you'll hand the artifact to. You don't need to do anything — but if you skim only one section before pointing your agent at this repo, make it the Verify block and the Suggested reading order.

WAIT — Solo project — review before adopting

• Last commit 6w ago
• MIT licensed
• ⚠ Solo or near-solo (1 contributor active in recent commits)
• ⚠ No CI workflows detected
• ⚠ No test directory detected

_{Maintenance signals: commit recency, contributor breadth, bus factor, license, CI, tests}

This artifact was generated by RepoPilot at a point in time. Before an agent acts on it, the checks below confirm that the live XCharts-Team/XCharts repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/XCharts-Team/XCharts.

What it runs against: a local clone of XCharts-Team/XCharts — the script inspects git remote, the LICENSE file, file paths in the working tree, and git log. Read-only; no mutations.

| # | What we check | Why it matters | |---|---|---| | 1 | You're in XCharts-Team/XCharts | Confirms the artifact applies here, not a fork | | 2 | License is still MIT | Catches relicense before you depend on it | | 3 | Default branch master exists | Catches branch renames | | 4 | Last commit ≤ 71 days ago | Catches sudden abandonment since generation |

#!/usr/bin/env bash
# RepoPilot artifact verification.
#
# WHAT IT RUNS AGAINST: a local clone of XCharts-Team/XCharts. If you don't
# have one yet, run these first:
#
#   git clone https://github.com/XCharts-Team/XCharts.git
#   cd XCharts
#
# Then paste this script. Every check is read-only — no mutations.

set +e
fail=0
ok()   { echo "ok:   $1"; }
miss() { echo "FAIL: $1"; fail=$((fail+1)); }

# Precondition: we must be inside a git working tree.
if ! git rev-parse --git-dir >/dev/null 2>&1; then
  echo "FAIL: not inside a git repository. cd into your clone of XCharts-Team/XCharts and re-run."
  exit 2
fi

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "XCharts-Team/XCharts(\\.git)?\\b" \\
  && ok "origin remote is XCharts-Team/XCharts" \\
  || miss "origin remote is not XCharts-Team/XCharts (artifact may be from a fork)"

# 2. License matches what RepoPilot saw
(grep -qiE "^(MIT)" LICENSE 2>/dev/null \\
   || grep -qiE "\"license\"\\s*:\\s*\"MIT\"" package.json 2>/dev/null) \\
  && ok "license is MIT" \\
  || miss "license drift — was MIT at generation time"

# 3. Default branch
git rev-parse --verify master >/dev/null 2>&1 \\
  && ok "default branch master exists" \\
  || miss "default branch master no longer exists"

# 5. Repo recency
days_since_last=$(( ( $(date +%s) - $(git log -1 --format=%at 2>/dev/null || echo 0) ) / 86400 ))
if [ "$days_since_last" -le 71 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~41d)"
else
  miss "last commit was $days_since_last days ago — artifact may be stale"
fi

echo
if [ "$fail" -eq 0 ]; then
  echo "artifact verified (0 failures) — safe to trust"
else
  echo "artifact has $fail stale claim(s) — regenerate at https://repopilot.app/r/XCharts-Team/XCharts"
  exit 1
fi

Each check prints ok: or FAIL:. The script exits non-zero if anything failed, so it composes cleanly into agent loops (./verify.sh || regenerate-and-retry).

XCharts is a pure-code data visualization library for Unity UGUI that renders 10+ built-in chart types (line, bar, pie, radar, scatter, heatmap, candlestick) plus 10+ advanced extensions (3D pie, 3D bar, funnel, gauge, Sankey) entirely through procedural geometry—no shader dependencies or texture assets required. It solves the problem of adding professional-grade interactive charts to Unity games and applications with runtime configurability and theme support. Monolithic structure: core charting engine in C# classes for each chart type (LineChart, BarChart, PieChart, etc.), component-based composition using Unity's serialization (series, axes, legend, tooltip components), Documentation~/zh and Documentation~/en contain parallel markdown-based API docs and configuration guides organized by feature area.

Unity game developers and interactive application builders who need to embed real-time data visualization dashboards into games or dashboards without learning complex graphics APIs; particularly those building analytics UIs, game stats displays, or data-driven applications targeting mobile and desktop platforms.

Actively maintained production-ready library: 2.4M+ lines of C# code across extensive built-in and extension chart implementations, bilingual documentation (zh/en) with API reference and tutorials, organized GitHub releases with version badges. Recent commit activity and closed issues indicate ongoing development, though no CI/CD badges visible in README suggest test infrastructure may be informal.

Single-language C# stack limits ecosystem contributions; monolithic codebase (all charts in one repo vs. modular packages) makes maintenance harder; no visible GitHub Actions CI, which increases regression risk on releases. Extension charts (3D, Sankey) quality depends on third-party contributor pool. Breaking changes between major versions are likely given the visualization domain's evolution.

Library is actively developed with multiple chart type support and extension ecosystem. Documentation covers tutorial01 (quick start), configuration manual, FAQ, and changelog. No specific PR/issue data visible in file list, but README indicates support for TextMeshPro and Unity 5.6+, suggesting ongoing compatibility work.

Clone: git clone https://github.com/XCharts-Team/XCharts.git → Open in Unity 5.6+ → Import as asset package. No npm/nuget package visible; installation is direct Git clone into Assets/ folder. See Documentation~/zh/tutorial01.md or Documentation~/en/tutorial01.md for first steps.

Daily commands: Import into Unity Editor (Assets/ folder) → Create GameObject → Attach chart component (e.g., LineChart) in Inspector → Configure series/axes/legend in Inspector UI → Play. Runtime: use C# API to SetData() and RefreshChart(). No separate dev server; all rendering happens in-engine.

• Documentation~/zh/tutorial01.md: 5-minute quick-start guide showing how to add chart components, configure series data, and customize axes—essential entry point for new contributors
• Documentation~/zh/api.md: Complete API reference for all chart classes, properties, and methods—required reading for understanding serialization and runtime API
• Documentation~/zh/configuration.md: Configuration manual covering all Inspector-configurable properties for themes, components, and chart-specific options
• Documentation~/zh/changelog.md: Version history and breaking changes documentation—critical for understanding API evolution and migration paths
• Documentation~/en/faq.md: Frequently asked questions and common pitfalls specific to Unity UGUI integration and performance tuning

For new chart types: create class inheriting from BaseChart in (inferred) Runtime/Chart/. For components: extend Component base in Runtime/Component/. For theme/style: modify theme serializable classes. For docs: edit Documentation~/zh/configuration.md or Documentation~/en/api.md. Review tutorial01.md structure for feature examples before implementing.

Unity version constraint (5.6+ minimum) may cause compatibility issues with very old projects; TextMeshPro is optional but recommended for text rendering, and switching between TextMesh and TextMeshPro mid-project can break existing charts. No visible package.json or Assembly Definition files (.asmdef) in file list suggests potential namespace collision risk if project has conflicting chart libraries. Documentation is bilingual (zh primary, en secondary), so some features may be explained better in Chinese docs.

• Procedural geometry generation — XCharts renders all chart visuals by generating mesh vertices and indices at runtime rather than using pre-made sprites/textures, so understanding mesh construction (vertices, triangles, UV mapping) is essential for extending chart types or debugging rendering artifacts
• Component-based serialization (Unity's [SerializeField]) — XCharts exposes all chart configuration through Unity Inspector serializable objects (Serie, XAxis, Legend), so modifying or extending configurable properties requires understanding Unity's serialization system and [SerializeField] attributes
• UGUI Canvas rendering and batching — XCharts charts are UGUI-based, so understanding Canvas render order, graphic batching, and raycaster interactions is critical for performance optimization and interaction handling in large-data scenarios
• Theme/style system abstraction — XCharts implements a theme system (mentioned in features as 'full parameter setting from theme to component') similar to ECharts; understanding how theme inheritance cascades to components and data items lets you customize appearance globally or per-series
• Multi-chart composition and axis sharing — XCharts supports 'combining multiple same or different chart types in one chart' (multiple series in single BaseChart), which requires understanding how axes are shared, data normalized across series types, and legend/tooltip coordinate mapping
• Event callback system for interactivity — Charts emit callbacks on click, hover, and data change; understanding how to wire these callbacks and pass chart coordinate context (data index, value, world position) to game logic is essential for interactive features
• Coordinate system abstraction (Cartesian, Polar, Single-axis) — XCharts supports multiple coordinate systems (mentioned: 'rectangular, polar, single-axis'); understanding how to transform data values to screen coordinates differently per system is key for implementing or debugging new chart types

• uisoft/ECharts — ECharts is the web charting inspiration/predecessor that XCharts emulates in architecture (component-based, theme system, series abstraction)
• Unity-Technologies/uGUI — XCharts depends entirely on Unity's UGUI (Canvas, GraphicRaycaster, LayoutGroup); understanding UGUI rendering pipeline is prerequisite
• textmesh-pro/TextMesh-Pro — XCharts optionally integrates TextMeshPro for superior text rendering in charts; understanding TMPro API required for text customization
• nity-Technologies/unity-performance-benchmark — XCharts is a procedural rendering library; understanding Unity profiler and batching strategies helps optimize large-dataset chart performance
• chartjs/Chart.js — Chart.js is the analogous JavaScript charting library; comparing implementations helps understand XCharts' design decisions for UGUI constraints

To work on one of these in Claude Code or Cursor, paste: Implement the "<title>" PR idea from CLAUDE.md, working through the checklist as the task list.

Add comprehensive unit tests for Editor drawer components

The Editor/ChildComponents directory contains multiple drawer classes (AnimationDrawer.cs, AreaStyleDrawer.cs, BackgroundDrawer.cs, etc.) that lack visible test coverage. These are critical UI editor components that deserved automated tests to prevent regressions when modifying inspector functionality. This would improve code quality and catch breaking changes early.

• [ ] Create Tests/Editor/Drawers directory structure
• [ ] Write unit tests for AnimationDrawer.cs covering OnGUI rendering and value updates
• [ ] Write unit tests for AreaStyleDrawer.cs and BackgroundDrawer.cs with mock SerializedProperty
• [ ] Add test cases for edge cases (null values, invalid data types, extreme values)
• [ ] Ensure tests can run in Unity Test Framework and integrate with CI

Add GitHub Actions workflow for automated chart rendering validation

As a data visualization library, XCharts should validate that charts render correctly across different Unity versions and configurations. Currently, .github/FUNDING.yml exists but there's no CI/CD workflow file visible. Adding automated tests that instantiate and render various chart types would catch visual regressions and platform compatibility issues.

• [ ] Create .github/workflows/unity-test.yml for automated testing
• [ ] Configure workflow to test against multiple Unity versions (2019 LTS, 2020 LTS, 2021 LTS, latest)
• [ ] Add step to run Unity tests in batch mode for all chart types
• [ ] Include chart rendering validation for the built-in chart examples mentioned in file structure
• [ ] Add workflow trigger for pull requests and pushes to main/master branches

Create API documentation index and missing feature documentation

Documentation~/en/api.md and Documentation~/zh/api.md exist but the file structure shows extensive Editor components (BaseChartEditor.cs, multiple drawer classes) and configuration options that likely lack detailed API documentation. Create a structured API reference that documents all public editor attributes and chart configuration options with examples.

• [ ] Audit Editor/Attributes/ComponentEditorAttribute.cs and SerieEditorAttribute.cs to identify all public APIs
• [ ] Create Documentation~/en/api-reference.md with complete attribute reference and code examples
• [ ] Document each drawer component's purpose in Documentation~/en/components.md (AnimationDrawer, AreaStyleDrawer, etc.)
• [ ] Add cross-references in Documentation~/en/configuration.md to link configuration options to their implementations
• [ ] Mirror all new documentation in Documentation~/zh/ for Chinese users

• Add unit tests for chart data validation: create test cases for Serie.AddData() and SetXAxisData() to catch edge cases like null values, negative data in pie charts, and duplicate axis labels—currently no Tests/ directory visible in file structure
• Expand English documentation: translate missing sections from Documentation~/zh/configuration.md to Documentation~/en/configuration.md, especially the advanced component customization examples and theme override syntax
• Create runnable Unity scene examples in Assets/Examples/ showing each of the 10+ built-in chart types with sample data and Inspector configurations—Documentation~/en/img/ has tutorial screenshots but no corresponding .unity scenes

The XCharts repository demonstrates generally sound security practices for a UI component library. No critical vulnerabilities were identified in the visible file structure. However, security governance could be improved by adding CODEOWNERS and SECURITY.md files. The main security concerns relate to potential input validation issues in the charting engine itself (not visible in the provided file structure). As a data visualization library, special attention should be paid to validating all external data sources to prevent injection attacks and ensuring safe deserialization of configuration data. The empty dependency information indicates a need for clearer dependency management documentation.

• Low · Missing CODEOWNERS file — .github/. The repository lacks a CODEOWNERS file in the .github directory. This makes it difficult to enforce code review policies and security governance, potentially allowing unauthorized changes to sensitive components. Fix: Create a CODEOWNERS file to define required reviewers for critical components, especially those handling data processing and rendering.
• Low · No security.md or security policy defined — .github/. There is no visible security policy or responsible disclosure document (.github/SECURITY.md). This makes it unclear how security vulnerabilities should be reported. Fix: Create a SECURITY.md file with clear instructions for reporting vulnerabilities responsibly, including contact information and expected response times.
• Low · Potential unsafe deserialization patterns in charting library — Runtime/ (source code not provided for detailed analysis). Based on the file structure, this is a charting/visualization library that likely processes external data. Without reviewing the source code, there's potential risk of unsafe deserialization if the library accepts serialized chart configurations without proper validation. Fix: Implement strict input validation for all external data sources. Use whitelisting for allowed configuration properties. Avoid using unsafe deserialization methods (e.g., BinaryFormatter in .NET).
• Low · No dependency lock file visible — Dependencies/. The provided dependency file content is empty. Without visible package lock files (package-lock.json, Packages/manifest.json for Unity), there's potential for supply chain vulnerabilities from transitive dependencies. Fix: Ensure all dependency versions are locked in manifest files. Regularly audit dependencies using tools like OWASP Dependency-Check or npm audit.

LLM-derived; treat as a starting point, not a security audit.

• Open issues — current backlog
• Recent PRs — what's actively shipping
• Source on GitHub

Generated by RepoPilot. Verdict based on maintenance signals — see the live page for receipts. Re-run on a new commit to refresh.