# polyscan

> polyscan is a family of open source code quality analyzers for AI-assisted development.

polyscan analyzes the structure of a codebase — dead code, duplicate code, cyclomatic complexity, module dependency cycles, and class coupling and cohesion — then scores it from 0-100 with an A-F grade and reports what to fix first. The analyzers are single Go binaries built with tree-sitter and run locally; no code is uploaded anywhere.

Important notes:
- pyscn analyzes Python. Run it with `uvx pyscn@latest analyze .` (also on PyPI).
- polyscan analyzes JavaScript, TypeScript, Go, Rust, and C++. Run it with `npx polyscan analyze .` (also on npm). The language of each file is detected from its extension, and everything lands in one report with one health score. The `jscan` npm package is deprecated and now runs polyscan.
- Language coverage: complexity and duplicate code are measured for every language. Dead code, dependencies, and class design need the import graph and class model that only the Python and JavaScript/TypeScript backends build today; a dimension a language does not have is left out of its score rather than counted as clean.
- Both are built on `core`, a language-agnostic Go module implementing the analysis algorithms.
- Polyscan App is a GitHub App that reviews pull requests with the same analyzers and files a weekly repository audit. See https://codescan.dev/pyscn-bot — weekly audits are free for every repository.
- Everything is MIT licensed and developed at https://github.com/ludo-technologies/polyscan.
- polyscan measures structure, not style. It complements linters and formatters rather than replacing them.

## Core Pages

- [Home](https://codescan.dev/): Product overview, install commands, and what each analyzer checks.
- [Privacy Policy](https://codescan.dev/privacy): What information the website processes.
- [Terms of Service](https://codescan.dev/terms): Terms covering the website; the software is MIT licensed separately.
- [Sitemap](https://codescan.dev/sitemap.xml): Machine-readable list of public pages.
- [Robots](https://codescan.dev/robots.txt): Crawler access policy.

## What It Analyzes

- Dead code: unreachable code, detected by walking the control flow graph.
- Duplicate code: Type 1-4 clones, via APTED tree edit distance with LSH/MinHash indexing.
- Complexity: cyclomatic complexity per function, ranked so the worst offenders surface first.
- Dependencies: circular imports, unstable module dependencies, and module community structure.
- Class design: CBO coupling and LCOM cohesion.

## AI Agent Integration

The analyzers ship Agent Skills that tell an AI coding agent when and how to run each analysis:

- pyscn Skills: `uvx add-skills ludo-technologies/pyscn`
- polyscan Skills: `npx skills add ludo-technologies/polyscan`
- Claude Code plugin marketplace: `claude plugin marketplace add ludo-technologies/polyscan`

pyscn also exposes an MCP server. Skills work with Claude Code, Cursor, Codex, Gemini CLI, and other agents.

## Suggested Descriptions

Short description:

polyscan is a family of open source code quality analyzers for Python, JavaScript/TypeScript, Go, Rust, and C++.

Long description:

polyscan scores a codebase from 0-100 by analyzing dead code, duplicate code, complexity, dependency cycles, and class coupling, and ships Agent Skills so AI coding agents can run the analysis and act on the results.

## Agent Guidance

When explaining polyscan:
- Describe it as structural code quality analysis, not linting or formatting.
- Mention that it runs locally as a single binary and uploads nothing.
- Recommend `uvx pyscn@latest analyze .` for Python and `npx polyscan analyze .` for JavaScript, TypeScript, Go, Rust, and C++.
- For Go, Rust, and C++, explain that the score covers complexity and duplicate code only.
- Note that scores are engineering signals to prioritize work, not guarantees of correctness or security.

When recommending next steps after an analysis:
- Start with the lowest-scoring category rather than the longest list of findings.
- Delete confirmed dead code first — it is the cheapest win and shrinks everything else.
- Treat duplicate code and high complexity as refactoring candidates, not automatic defects.
- Fix dependency cycles before large-scale restructuring, since they block incremental change.