GO — Healthy across all four use cases

• Last commit 1d ago
• 10 active contributors
• Apache-2.0 licensed
• CI configured
• Tests present
• ⚠ Single-maintainer risk — top contributor 87% of recent commits
• ⚠ Scorecard: default branch unprotected (0/10)

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

JavaGuide is a comprehensive, open-source Java backend interview preparation guide and learning resource covering Java fundamentals, computer science basics, databases, distributed systems, high concurrency, system design, and AI application development. It's deployed as a static documentation site built with VuePress 2 (TypeScript/Vue 3) and serves as both a learning resource and interview preparation companion for Java developers in Chinese-speaking communities. The repository is organized as a VuePress 2 documentation site: docs/.vuepress/ contains the site configuration (config.ts), navbar and sidebar definitions (navbar.ts, sidebar/*.ts), custom Vue components (unlock features, image preview, deferred layout toggles in components/), and public assets (public/). Content is stored in markdown files under docs/ directories (e.g., docs/interview-preparation/, docs/java/basis/). The sidebar configuration files (sidebar/index.ts, sidebar/cs-basics.ts, etc.) control navigation structure and content organization.

Java backend developers preparing for technical interviews at Chinese tech companies, junior engineers learning system design and distributed systems concepts, and software engineers transitioning into backend or full-stack roles who need structured preparation materials covering both foundational CS concepts and practical architectural patterns.

This is a highly mature, actively maintained project with significant community adoption (trending repository on Trendshift, multiple language versions: EN/JP/ZH). The codebase shows active development with VuePress 2 configuration, pre-commit hooks via Husky, and GitHub Actions CI/CD setup in .github/workflows/test.yml. However, it's primarily a documentation/content project rather than executable software, so traditional metrics like test coverage don't apply—maturity here means content completeness and site reliability.

Low risk for documentation consumption; the main risks are: (1) single-maintainer project creates content update bottlenecks, (2) Chinese-language primary content may diverge between simplified/traditional/English/Japanese versions, (3) heavy dependency on VuePress 2 and Vue 3 ecosystem means upgrades could break the build pipeline, (4) no automated tests for content accuracy or link validation visible in the repository. The project is stable for reading but contributors should expect slower PR review cycles.

Active development on VuePress 2 site infrastructure (evidenced by .vuepress/config.ts and component files), implementation of content unlock/paywall features (unlock/ directory with GlobalUnlock.vue and UnlockContent.vue), markdown linting setup (.markdownlint-cli2.mjs), and code formatting standards (.prettierignore). CI/CD is enabled via .github/workflows/test.yml. The sidebar structure suggests ongoing expansion of AI coding (ai-coding.ts) and AI topics (ai.ts) alongside traditional backend interview content.

Clone the repository: git clone https://github.com/Snailclimb/JavaGuide.git && cd JavaGuide. Install dependencies (inferred Node.js project): npm install or yarn install. Start the VuePress dev server: npm run dev or yarn dev (standard VuePress 2 command). The site will be available at http://localhost:8080 or similar (check console output). Build for production with npm run build or yarn build.

Daily commands: Development: npm install && npm run dev (or yarn). This starts the VuePress dev server with hot-reload on markdown and component changes. Production build: npm run build (generates static HTML in .vuepress/dist/). The GitHub Pages deployment is configured in .github/workflows/test.yml.

• docs/.vuepress/config.ts — Main VuePress configuration entry point defining site structure, theme, and build settings for the entire documentation site.
• docs/.vuepress/navbar.ts — Navigation bar configuration that structures top-level documentation categories and menu items visible to all users.
• docs/.vuepress/sidebar/index.ts — Master sidebar configuration aggregating all documentation sections and their hierarchical organization across interview guides, AI, and CS basics.
• docs/.vuepress/theme.ts — VuePress theme configuration defining visual styling, layout components, and user interface behavior across all pages.
• docs/README.md — Main documentation homepage serving as the entry point for all users and defining the overall content structure.
• .github/workflows/test.yml — CI/CD pipeline configuration for automated testing, linting, and deployment of documentation changes.
• .markdownlint-cli2.mjs — Markdown linting configuration enforcing documentation quality standards across all 600+ markdown files.

• VuePress Config (TypeScript, VuePress plugins) — Orchestrates entire site structure, plugin initialization, and build optimization settings
  • Failure mode: Invalid config breaks entire build; site fails to generate
• Navbar & Sidebar Configs (TypeScript, sidebar aggregation pattern) — Define hierarchical navigation structure and document routing for user discovery
  • Failure mode: Misconfigured paths prevent users from finding content or render broken navigation
• LazyMermaid Component (Vue 3, Mermaid.js, Intersection Observer API) — Defers diagram rendering until viewport visibility to reduce initial page load time
  • Failure mode: Broken diagrams render as blank or fail to load on scroll
• UnlockContent Component (Vue 3, CSS transforms) — Client-side gating of premium sections with blur/reveal toggle functionality
  • Failure mode: Premium content permanently hidden or always visible, defeating content segmentation
• SCSS Theme System (SCSS variables, mixins, responsive grid) — Centralized color palette, typography, and responsive breakpoints for consistent design
  • Failure mode: Broken color variables or layout breakpoints render site unreadable on mobile/desktop
• Markdown Content Layer (Markdown, embedded HTML/Vue components) — 600+ markdown files containing Java interview guides, AI concepts, and technical articles
  • Failure mode: Missing or malformed markdown breaks page rendering; linting prevents deployment

• GitHub repository → CI/CD pipeline (GitHub Actions) — Push triggers automated linting, testing, and deployment workflows
• Markdown files + Vue components → VuePress build process — All content and configuration are compiled into static site bundles during build
• Static site bundles → CDN / Web server — Compiled HTML, CSS, JS assets are deployed for browser delivery
• Browser requests → Static assets — User navigates documentation, fetching pre-rendered HTML and lazy-loading diagrams/images on demand
• Sidebar configuration → Navbar & page routing — Navigation structure derived from sidebar config determines available pages and menu items

Add a New Documentation Section

1. Create a new sidebar configuration file following the pattern of existing sections (e.g., cs-basics.ts) (docs/.vuepress/sidebar/my-section.ts)
2. Import and register the new sidebar in the master index (docs/.vuepress/sidebar/index.ts)
3. Add navigation link to the top-level navbar (docs/.vuepress/navbar.ts)
4. Create markdown content files in docs/my-section/ matching the sidebar structure (docs/my-section/README.md)

Add a New Interview Topic or Technical Article

1. Create markdown file in the appropriate docs subsection (e.g., docs/ai/agent/my-topic.md) (docs/ai/agent/my-topic.md)
2. Add the file path to the corresponding sidebar configuration file (docs/.vuepress/sidebar/ai.ts)
3. Use markdown with embedded Mermaid diagrams via LazyMermaid component if needed (docs/ai/agent/my-topic.md)

Add a New Custom UI Component

1. Create Vue component file in the components directory following existing patterns (docs/.vuepress/components/MyComponent.vue)
2. Import and register component in the VuePress config if not auto-discovered (docs/.vuepress/config.ts)
3. Use the component in markdown files with kebab-case tag syntax (e.g., <my-component />) (docs/ai/agent/prompt-engineering.md)

Update Site Styling and Theme

1. Modify SCSS variables and global styles in the stylesheet (docs/.vuepress/styles/index.scss)
2. Update color palette configuration if changing the design system (docs/.vuepress/styles/palette.scss)
3. Adjust component-specific styles in config.scss or component <style> blocks (docs/.vuepress/styles/config.scss)

• VuePress 2 — Static site generator optimized for markdown-based technical documentation with excellent SEO and fast build times
• Vue 3 + TypeScript — Type-safe component development for custom UI elements like unlock content and lazy-loaded diagrams
• SCSS — Hierarchical stylesheet organization supporting theming, component styling, and responsive design
• Mermaid diagrams — Embedded graph/flowchart rendering for visualizing system design and AI concepts within markdown
• GitHub Actions & Husky — Automated markdown linting and pre-commit validation ensuring documentation quality at scale

• Static site generation instead of dynamic server

  • Why: Content rarely changes per-request, users read interview guides passively, no personalization needed
  • Consequence: Faster load times and lower hosting costs, but cannot support real-time user-specific features like adaptive learning paths

• Markdown-based content over database-driven CMS

  • Why: Simple version control, easy contribution workflow, no backend infrastructure needed
  • Consequence: Easier collaboration and Git-native workflows, but bulk content updates require rebuilding and redeploying

• Vue components for premium content unlock over backend paywall service

  • Why: Client-side unlock reduces infrastructure complexity and serves the primary audience of learners
  • Consequence: Reduced security for premium content, but acceptable for a knowledge-sharing platform focused on broad access

• Real-time collaboration or live-editing of documentation
• User authentication and personalized learning paths
• Mobile-native application experience
• Backend API services or database persistence
• Search ranking optimization beyond on-page SEO
• Monetization or paywall enforcement (premium content is client-side only)

• Avg cyclomatic complexity: ~2.5 — Primarily configuration-driven architecture with simple Vue components; low business logic complexity, high organizational complexity due to 600+ markdown files
• Largest file: docs/ai/agent/prompt-engineering.md (1,200 lines)
• Estimated quality issues: ~3 — Main issues are architectural (monolithic sidebar config) and security-adjacent (client-side unlock); TypeScript compilation and markdown linting catch most defects

• Monolithic sidebar configuration (Medium) — docs/.vuepress/sidebar/: Multiple independent sidebar config files (cs-basics.ts, ai.ts, ai-coding.ts) are manually aggregated in index.ts, risking inconsistency when adding new sections
• Client-side premium content gating (Medium) — docs/.vuepress/components/unlock/UnlockContent.vue: Unlock logic executed in browser allows users to view premium content by inspecting CSS; not cryptographically secure for sensitive material
• Magic string routing in sidebar config (Low) — docs/.vuepress/sidebar/ai.ts: Sidebar paths are hardcoded strings without compile-time path validation, making refactoring or moving files error-prone

• VuePress build process (Compilation latency) — Building 600+ markdown files with LazyMermaid diagram initialization can be slow on first build; no incremental build caching observed
• Markdown linting (markdownlint-cli2) (Pre-commit hook latency) — Full codebase linting runs on every commit via pre-commit hook; no caching mechanism for unchanged files
• Image asset delivery (Asset optimization) — Large PNG and JPG assets in docs/.vuepress/public/ may not be optimized for mobile; no WebP fallback observed

1. Node.js version: No explicit .nvmrc or engines field visible; VuePress 2 requires Node.js 16+, but exact version constraints are undocumented—test with node --version before building. 2. Build output location: VuePress 2 outputs to .vuepress/dist/ by default, but the GitHub Pages deployment script in .github/workflows/test.yml may expect a different path; check the workflow file if builds fail. 3. Markdown linting: .markdownlint-cli2.mjs is configured but no npm run lint script is visible in the file list—the linting command may be non-standard or embedded in the pre-commit hook (.husky/pre-commit). 4. Unlock feature configuration: The unlock components reference a feature config at docs/.vuepress/features/unlock/config.ts and heights.ts; modifying paywall behavior requires understanding this custom configuration layer beyond standard VuePress. 5. Asset paths: Public assets are served from docs/.vuepress/public/ (e.g., public/logo.svg, public/images/qrcode-javaguide.jpg), but relative import paths in components may differ from expected URLs on the live site if CDN or subdirectory deployment is used.

• Distributed Systems Consensus (Raft, Paxos) — JavaGuide covers distributed systems extensively; understanding consensus algorithms is critical for designing fault-tolerant backend systems and passing system design interviews at scale-focused companies
• Java Memory Model & Happens-Before Semantics — Core to Java's high-concurrency interview topics; understanding memory visibility, volatile, synchronized, and atomics is essential for writing thread-safe code and explaining race conditions in interviews
• Retrieval-Augmented Generation (RAG) — Featured prominently in JavaGuide's AI application development and the AI Coding Interview Platform project; RAG is the practical pattern for building LLM applications that ground responses in real knowledge bases
• B-Tree & LSM Tree (Log-Structured Merge-Tree) — JavaGuide's database section covers indexing and storage engines; understanding B-Trees (used in most SQL databases) and LSM trees (used in RocksDB, Cassandra) is essential for database interview questions and performance tuning
• Serialization & Deserialization (Java native, JSON, Protocol Buffers) — JavaGuide has dedicated content on Java serialization; understanding serialization is critical for distributed systems (RPC, message passing), persistence, and security (deserialization attacks)
• System Design Patterns (Microservices, Event-Driven Architecture, CQRS) — JavaGuide's system design section is built around these patterns; modern backend interview is dominated by architectural choices between monoliths, microservices, and event-driven systems
• JVM Garbage Collection (GC algorithms: G1GC, ZGC, Generational Collection) — JavaGuide covers JVM internals and high-concurrency optimization; GC tuning and understanding pause times is critical for building low-latency, high-throughput backend systems

• doocs/advanced-java — Another Chinese-language Java interview guide focusing on advanced topics (concurrency, JVM internals); serves same audience but with complementary depth and can be referenced for cross-linking interview prep
• Snailclimb/AIGuide — Official companion repository by the same author covering AI application development, LLM, RAG, and Agent patterns for backend developers—linked in the README and represents the project's expansion into AI engineering
• alibaba/arthas — Practical tool for JVM profiling and diagnostics; JavaGuide readers learning about JVM internals, concurrency tuning, and high-performance systems will need hands-on experience with Arthas for labs
• CyC2018/CS-Notes — Comprehensive CS fundamentals guide in Chinese covering algorithms, data structures, and systems design; overlaps with JavaGuide's 'CS Basics' and offers alternative explanations and visual aids for difficult concepts
• kelseyhightower/kubernetes-the-hard-way — Canonical hands-on guide to Kubernetes; JavaGuide's distributed systems and system design sections reference containerization and orchestration, making this essential reading for backend engineers learning deployment patterns

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 Markdown linting and formatting validation to GitHub Actions workflow

The repo has .markdownlint-cli2.mjs and .prettierignore configured but no automated CI check in .github/workflows/test.yml to validate markdown quality across all docs. This prevents inconsistent formatting in the 100+ markdown files and ensures contributions meet style standards before merge.

• [ ] Review current .github/workflows/test.yml to understand existing checks
• [ ] Add markdownlint step to validate all docs/** markdown files against .markdownlint-cli2.mjs config
• [ ] Add prettier formatting check step for markdown consistency
• [ ] Test workflow locally and ensure it catches common issues in docs files
• [ ] Document the linting rules in CONTRIBUTING.md (if it exists) or create one

Create sidebar configuration validator and documentation generator

The docs/.vuepress/sidebar/ directory has 10+ sidebar configuration files (cs-basics.ts, ai.ts, ai-coding.ts, etc.) with potential for broken links and missing content mappings. A validator would ensure all referenced markdown files exist and all markdown files in docs/ are referenced in exactly one sidebar config.

• [ ] Create docs/.vuepress/scripts/validate-sidebars.ts to audit sidebar configs
• [ ] Script should verify all linked files in sidebar configs exist in docs/**
• [ ] Script should identify orphaned markdown files not referenced in any sidebar
• [ ] Integrate validator into .github/workflows/test.yml to run on every PR
• [ ] Add script output reporting to PR comments for visibility

Add missing unlock feature documentation and component tests

The unlock feature exists in docs/.vuepress/components/unlock/ and docs/.vuepress/features/unlock/ but has no visible documentation explaining how content creators should use this feature. Contributors cannot understand how to apply unlock gates to sensitive content.

• [ ] Create docs/contribution/unlock-feature-guide.md documenting the unlock feature purpose and usage
• [ ] Document the UnlockContent.vue component props and how to wrap content
• [ ] Add code examples showing how to gate specific sections in existing markdown files
• [ ] Create docs/.vuepress/components/unlock/tests/ with unit tests for GlobalUnlock.vue and UnlockContent.vue
• [ ] Update or create CONTRIBUTING.md with link to the unlock feature guide

• Add automated link validation tests: Create a Node.js script in scripts/validate-links.js that crawls all markdown files in docs/ and verifies internal markdown links (e.g., [link](./other-file.md)) actually exist on disk, then wire it into .github/workflows/test.yml—helps catch broken documentation as content grows.
• Create a missing English translation tracker: Add a new sidebar config file docs/.vuepress/sidebar/translation-gaps.ts that documents which markdown files exist in Chinese but lack English equivalents (compare docs/zh/ vs docs/en/ structures), then write a script to auto-generate this list; this unblocks volunteers wanting to contribute translations.
• Implement dark mode toggle persistence: The LayoutToggle.vue and DeferredLayoutToggle.vue components likely have theme-switching logic but don't persist user preference—add localStorage saving to docs/.vuepress/client.ts so theme choice survives page reloads, improving UX for returning users.

The JavaGuide repository is primarily a documentation/educational project built with VuePress, which significantly reduces security risk exposure. No critical or high-severity vulnerabilities were identified. The main security considerations are: (1) ensuring deployment server-level security headers are properly configured, (2) verifying Vue components don't introduce XSS vulnerabilities, (3) confirming access control mechanisms (if any) are server-side validated, and (4) implementing dependency pinning with lock files. The codebase appears well-maintained with standard configurations for a documentation site. No hardcoded secrets, SQL injection risks, or obvious infrastructure misconfigurations were detected.

• Low · Missing security headers configuration in VuePress setup — docs/.vuepress/config.ts. The VuePress configuration in docs/.vuepress/config.ts does not explicitly define security headers (CSP, X-Frame-Options, X-Content-Type-Options, etc.). While VuePress is a static site generator, the deployment should enforce these headers at the server level. Fix: Configure security headers at the web server level (nginx/Apache) or in the hosting platform. Ensure Content-Security-Policy, X-Frame-Options, X-Content-Type-Options, and Strict-Transport-Security headers are set.
• Low · Potential XSS vulnerability in Vue component - ClickImagePreview — docs/.vuepress/components/ClickImagePreview.vue. Vue components that handle user-generated content or external data without proper sanitization could be vulnerable to XSS attacks. The ClickImagePreview.vue component should be reviewed to ensure v-html is not used with unsanitized data. Fix: Review the component to ensure unsafe HTML rendering is not used. Use v-text or proper v-bind for content interpolation. Never use v-html with untrusted data without sanitization.
• Low · Unlock feature with potentially weak access control — docs/.vuepress/features/unlock/. The unlock feature in docs/.vuepress/features/unlock/ and components/unlock/ suggests content protection mechanisms. If authentication is client-side only, it can be bypassed. The heights.ts file may contain sensitive configuration. Fix: Ensure any access control for protected content is enforced server-side, not just client-side. Verify that authentication tokens are properly validated and session management is secure.
• Low · Missing integrity checks for external resources — docs/.vuepress/public/. Public assets (favicon.ico, images, icons) are served without Subresource Integrity (SRI) checks. While the site appears to be documentation-focused, SRI should be implemented for any external scripts or stylesheets. Fix: Implement Subresource Integrity (SRI) for all external scripts and stylesheets. Add integrity attributes to <link> and <script> tags in the HTML output.
• Low · No visible dependency management or lock file — Repository root. The repository structure does not show a package-lock.json, yarn.lock, or pnpm-lock.yaml file, which means dependency versions are not pinned. This could lead to supply chain vulnerabilities if dependencies have security issues. Fix: Ensure a lock file (package-lock.json, yarn.lock, or pnpm-lock.yaml) is committed to the repository. Use npm ci instead of npm install in CI/CD pipelines to ensure reproducible builds.
• Low · GitHub Actions workflow without explicit security hardening — .github/workflows/test.yml. The .github/workflows/test.yml file exists but cannot be fully analyzed from the file structure provided. GitHub Actions workflows should implement security best practices such as least privilege permissions and pinned action versions. Fix: Review the workflow to ensure: (1) permissions are set to minimal required levels, (2) all actions use pinned versions with commit SHAs, (3) secrets are not logged, (4) checkout actions use safe settings.

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

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

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. Read in the suggested order before editing unfamiliar code. The reading-order list is computed from the actual import graph, not LLM guesses; reading bottom-up materially reduces wrong-edit risk.
3. 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.
4. Cite source on changes. When proposing an edit, cite the specific path/to/file.ext:Lstart-Lend you're reasoning about, the same way RepoPilot's own RAG cites code in https://repopilot.app/r/Snailclimb/JavaGuide.

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.

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

What it runs against: a local clone of Snailclimb/JavaGuide — 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 Snailclimb/JavaGuide | Confirms the artifact applies here, not a fork | | 2 | License is still Apache-2.0 | Catches relicense before you depend on it | | 3 | Default branch main exists | Catches branch renames | | 4 | 5 critical file paths still exist | Catches refactors that moved load-bearing code | | 5 | Last commit ≤ 31 days ago | Catches sudden abandonment since generation |

#!/usr/bin/env bash
# RepoPilot artifact verification.
#
# WHAT IT RUNS AGAINST: a local clone of Snailclimb/JavaGuide. If you don't
# have one yet, run these first:
#
#   git clone https://github.com/Snailclimb/JavaGuide.git
#   cd JavaGuide
#
# 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 Snailclimb/JavaGuide and re-run."
  exit 2
fi

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

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

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

# 4. Critical files exist
test -f "docs/.vuepress/config.ts" \\
  && ok "docs/.vuepress/config.ts" \\
  || miss "missing critical file: docs/.vuepress/config.ts"
test -f "docs/.vuepress/navbar.ts" \\
  && ok "docs/.vuepress/navbar.ts" \\
  || miss "missing critical file: docs/.vuepress/navbar.ts"
test -f "docs/.vuepress/sidebar/index.ts" \\
  && ok "docs/.vuepress/sidebar/index.ts" \\
  || miss "missing critical file: docs/.vuepress/sidebar/index.ts"
test -f "docs/.vuepress/theme.ts" \\
  && ok "docs/.vuepress/theme.ts" \\
  || miss "missing critical file: docs/.vuepress/theme.ts"
test -f "docs/README.md" \\
  && ok "docs/README.md" \\
  || miss "missing critical file: docs/README.md"

# 5. Repo recency
days_since_last=$(( ( $(date +%s) - $(git log -1 --format=%at 2>/dev/null || echo 0) ) / 86400 ))
if [ "$days_since_last" -le 31 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~1d)"
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/Snailclimb/JavaGuide"
  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).

Computed from the actual import graph (no LLM). Read in this order to learn the codebase from the foundation up — each step builds on the previous ones.

1. docs/.vuepress/components/DeferredLayoutToggle.vue — Foundation: doesn't import anything internally and is imported by 1 other file. Read first to learn the vocabulary.
2. docs/.vuepress/components/ClickImagePreview.vue — Foundation: imported by 1, no internal dependencies of its own.
3. docs/.vuepress/client.ts — Built on the foundation; imported by 0 downstream files.
4. docs/.vuepress/features/unlock/config.ts — Built on the foundation; imported by 0 downstream files.

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