v2.0 — Java AST engine, live

Code quality
enforcement,
from the IDE
to the org.

ScaleArch is a three-part platform for catching mechanical, repeatable code issues — SQL injection, N+1 queries, SOLID violations, your company's deprecated APIs — before they ever reach review. Local. Deterministic. Zero AI runtime.

● No AI calls ● No internet required ● No per-seat pricing ● Open source
12131415 16171819 20212223 24
async getUsersByIds(ids: string[]) { const results = []; for (const id of ids) { const user = await db.query("SELECT * FROM users WHERE id = ?", [id]); results.push(user); } return results; } function login(user, remember = false) { const key = "sk_live_4eC39Hq..."; try { auth(user, key); } catch (e) {}
↑ Hover any underlined token to see the diagnostic
80+
Built-in rules
5
Languages
600ms
Debounced feedback
0
Network calls at runtime
The problem

Senior engineers waste hours catching the same issues every sprint.

SELECT *. Empty catch blocks. Hardcoded secrets. 200-line functions. SQL queries firing inside loops. These are not architectural debates — they're mechanical, repeatable, and catchable by a machine.

Generic linters exist. But they don't know your company's standards. They don't know PaymentV1 was deprecated last quarter, that every fetch must go through your internal HttpClient, or that three incidents proved every async function needs a try/catch.

That knowledge lives in Confluence. In PR comments. In onboarding calls that don't scale. ScaleArch gives it a home in code.

// today
📄 company-standards.md
💬 Slack threads
👀 PR review nitpicks
🤝 Onboarding tribal knowledge
→ enforced inconsistently, by humans
// with ScaleArch
📦 customRules.ts
Written once. Enforced forever.
Live on every save, in every editor.
→ enforced deterministically, by the machine
The platform

One platform. Three surfaces. One coherent answer to organizational code quality.

The Extension catches issues at the keystroke. The Rule Builder lets anyone author org-specific rules without learning AST internals. The Validator gives engineering leadership governance, audit logs, and an API for CI.

01 — VS Code

ScaleArch Extension

Real-time static analysis in your editor

Two engines run on every keystroke. The Regex Engine catches DB anti-patterns and security issues line-by-line. The AST Engine parses the file into a syntax tree and catches structural problems regex can never see — SOLID violations, deep nesting, empty catch blocks.

Live TS · webpack · tree-sitter
02 — Web

ScaleArch Rule Builder

Author rules without writing parser code

Fill in a form — name, message, severity, language, pattern. Get back production-ready TypeScript ready to paste into customRules.ts. 54-pattern library. AST node picker. Regex tester. Verify-with-Claude flow for a second opinion before shipping.

Live Vanilla JS · GH Pages
03 — SaaS

ScaleArch Validator

API + dashboard for org-wide governance

REST API your CI pipeline or save flow calls to validate code against your org's active ruleset. Dashboard for engineering leadership: API call volume, pass/fail rates, most-triggered rules, language breakdown. Every POST /validate call is logged — filterable by API key, time range, and language. API keys per team or service. Enable/disable built-in regex rules per org. Author custom regex rules through the UI without touching code.

Live React · Express · Supabase
01 / Extension

Two engines, one extension, every save.

ScaleArch routes through an AstGateway that picks the right parser per language. Adding a new language is one file and one line.

REGEX ENGINE — line-by-line, all languages
SELECT *, missing WHERE, hardcoded secrets, eval(), shell=True, SQL string concatenation, strcpy, sprintf, raw new in C++…
AST ENGINE — structure-aware, per language
JS/TS via @typescript-eslint · Python via built-in ast · Java via tree-sitter · 13 dedicated Java rules including method length, empty catch, public non-final fields, == on Strings.

What it catches, by category

DB

Database

db/no-select-star
db/no-where-clause
db/query-in-loop · N+1
db/leading-wildcard-like
db/delete-without-where
db/update-without-where
SEC

Security

security/hardcoded-secret
security/eval-usage
py/exec-usage · py/shell-true
java/sql-concatenation
cpp/gets · strcpy · sprintf
PERF

Performance

perf/await-in-loop
perf/sync-fs-call
perf/json-parse-in-loop
java/string-concat-in-loop
py/new-object-in-loop
SOLID

SOLID & Quality

  • solid/srp10+ method classes
  • solid/dipconcrete-class injection
  • quality/function-too-long
  • quality/high-complexity
  • quality/deep-nesting
PY-AST

Python AST

  • py/ast-function-too-long
  • py/ast-class-too-many-methods
  • py/ast-missing-docstring
  • py/ast-no-type-hints
  • py/ast-init-too-complex
JAVA-AST

Java AST (v2.0)

  • java/ast-empty-catch
  • java/ast-system-exit
  • java/ast-thread-sleep
  • java/ast-string-equals-compare
  • java/ast-public-field+ 8 more
02 / Rule Builder

Skip the AST tutorial. Ship the rule.

Writing a custom lint rule from scratch means understanding AST node shapes, tree-sitter property names, TypeScript generics, and webpack externals. That's a steep barrier for any team that doesn't have a compiler engineer on staff.

The Rule Builder eliminates it. Single-page web app. No backend. No accounts. Pick a pattern from the 54-pattern library, tweak it, regex-test against sample code, and copy production-ready TypeScript to your clipboard.

  • → 54 ready-made patterns across 5 languages
  • → Searchable AST node picker with code examples
  • → Live regex tester against your own sample
  • → "Verify with Claude" — copies a tuned prompt for sanity-check
  • → Documented 6-step pattern for adding new languages
03 / Validator

Save-time guardrails, audit logs, and a dashboard.

The Validator is a separate runtime service — its own dashboard for authoring regex rules per language, its own auth and API keys, and a single POST /validate endpoint to wire into save flows, CI pipelines, or any system that writes data.

Every POST /validate is audited: language, line count, errors found, rules triggered, processing time. Filterable by API key, time range, and language with sub-second queries.

POST /validate
Run code through the org's active ruleset
GET /rules
List built-in + custom rules for the org
GET /audit
Filterable audit log, sub-second queries
/apikeys CRUD
Expiry warnings, instant deactivation
POST /validate
123456
// Request { "language": "typescript", "code": "db.query('SELECT * FROM users')" } // header: x-api-key: sa_live_•••
200 OK · 1 error
123456789101112
{ "valid": false, "errorCount": 1, "errors": [{ "line": 1, "ruleId": "db/no-select-star", "severity": 0, "message": "Avoid SELECT *" }], "meta": { "rulesChecked": 62, "processingMs": 3 } }
Validator dashboard screenshot placeholder
Architecture

Two tracks. One philosophy.

The Extension and Rule Builder are one product family — IDE-time static analysis, regex across 5 languages, AST for JS/TS/Python/Java. The Validator is a separate runtime service — its own UI for authoring regex rules, called at the moment data is saved (form submits, API writes, scheduled pipelines). Same mindset, different enforcement point.

IDE-time Author once → enforce on every keystroke
Authoring (web)
Rule Builder
─ generates ─▶
Code
customRules.ts
─ paste into ─▶
Forked + packaged
VS Code Extension
─ ships as ─▶
On every developer
Squigglies on save
Runtime Author in dashboard → block at save time
Authoring (dashboard UI)
Validator: regex rules
─ stored in ─▶
Service
POST /validate
─ called by ─▶
Org systems
Save flows · CI · pipelines
─ visibility ─▶
Leadership
Audit log + dashboard
Important — these are independent. The Validator does not share rule code with the Extension. It supports regex only and is authored through its own UI, not by editing customRules.ts. Pick the track that fits the enforcement point: IDE for human-readable feedback as code is written, runtime for save-time guardrails on data and APIs the IDE can't see.
Developer experience

A new org-wide rule is one file, one function, zero ceremony.

Five sections in customRules.ts cover every flavour of rule — regex, JS/TS AST, whole-AST, Python AST, Java tree-sitter. Pick the section, write the check function, ship.

customRules.ts — regex rule
12345 678910 11
// Ban raw fetch — use HttpClient { id: 'company/no-raw-fetch', category: 'code-quality', severity: DiagnosticSeverity.Error, message: 'Direct fetch() not allowed —' + ' use @company/HttpClient', hint: 'HttpClient handles auth,' + ' retries, error logging.', test: (line) => /\bfetch\s*\(/.test(line), },
customRules.ts — Java AST rule
12345 678910 11
// Flag deprecated PaymentV1 API (node, _cfg, makeDiag) => { if (node.type !== 'method_invocation') return null; const obj = node.childForFieldName('object')?.text; if (obj !== 'PaymentV1') return null; return makeDiag(node, 'PaymentV1 deprecated — migrate to V2', Severity.Error, 'company/no-payment-v1'); },
Where it fits

Not a replacement for ESLint. A layer above it.

Generic linters do generic linting well. ScaleArch does what they don't: cross-language org rules, structural anti-patterns, and a no-AST-required path to authoring them.

ESLint SonarQube AI code review ScaleArch
Cross-language with one ruleset No Yes Probabilistic Yes — 5 langs
Author rules without AST knowledge No No N/A — no rules Yes — Rule Builder
Real-time in IDE Yes Plugin PR-time Yes — <600ms
Deterministic / no AI Yes Yes No Yes
Works offline / on airgap Yes Yes No Yes
Org-wide governance + audit No Yes Limited Yes — Validator
Cost model Free $$ enterprise $ per seat Free + open source
For organizations

Tribal knowledge → enforced standard, in one afternoon.

ScaleArch is designed to be forked. A staff engineer spends an afternoon writing the rules that come from your last six post-mortems. Distributes the .vsix internally. Every developer — from day one — gets your company's coding standards enforced live, in their editor.

Pair with the Validator and the same rules block bad PRs in CI. The dashboard tells leadership which standards developers struggle with most.

A staff engineer's afternoon
14:00 Fork ScaleArch
14:15 Add 8 rules to customRules.ts
15:30 vsce package → company-scalearch.vsix
15:45 Publish to internal marketplace
16:00 Wire POST /validate into save flows
17:00 200 devs · day one · standards enforced

Real org-rule examples

company/no-raw-fetch
"Use our internal HttpClient — handles auth, retries, error logging."
company/no-payment-v1
"PaymentV1 deprecated. See migration guide: confluence.company.com/payment-v2"
company/db-via-querybuilder
"All DB queries must go through QueryBuilder — never raw SQL strings."
Why now

In a world chasing AI for everything, I built the boring, deterministic, instant version.

// shifted left

Further left than any tool you have.

Not at PR-time. Not at CI-time. At keystroke-time. The feedback loop is milliseconds, not hours, not days.

// no AI runtime

Works on the plane.

No tokens. No quotas. No flaky API. Works on a plane, on an airgap, on day one and day one thousand. Same answer, every time.

// org first

Built for real teams.

API keys, audit logs, dashboard, rule overrides. Solo dev gets value alone. 200-dev org gets governance.

Good code standards
should enforce themselves.

All three products are live and free to use. The Extension repo is public and forkable.

Install Extension Open Rule Builder Validator dashboard
{ } ScaleArch The Platform

Code quality
enforcement,
from the IDE
to the org.

A three-part platform — Extension, Rule Builder, Validator — for catching mechanical, repeatable code issues before they ever reach review.

The problem

Senior engineers spend hours every sprint catching the same mechanical issues.

DB

SELECT *

Empty WHERE clauses. Queries inside loops. N+1 problems.

SEC

Hardcoded secrets

Plain-text API keys. eval(). SQL string concatenation.

QUAL

200-line functions

Empty catch blocks. Deep nesting. God objects. Boolean params.

These aren't architectural debates. They're mechanical, repeatable, catchable by a machine.

The gap

Generic linters don't know your codebase.

They don't know PaymentV1 was deprecated last quarter. They don't know every fetch must use your internal HttpClient. That every async function needs a try/catch — three incidents proved it.

// today
📄 Confluence pages
💬 Slack threads
👀 PR review nitpicks
🤝 Tribal knowledge
→ inconsistent, by humans
// with ScaleArch
📦 customRules.ts
Written once.
Enforced live in every editor.
Audited at every CI run.
→ deterministic, by the machine
The platform

One platform.
Three surfaces.

01 — VS Code

Extension

Real-time static analysis. Two engines (regex + AST). Live squigglies on every save.

02 — Web

Rule Builder

Author rules without writing parser code. 54-pattern library. Generates production TypeScript.

03 — SaaS

Validator

API + dashboard for governance. CI-time enforcement. API keys, audit logs, sub-second queries.

A team lead writes a rule once. It runs in every developer's editor before a PR is opened. One rule. Every keystroke.

01 / Extension · Live demo

Squigglies appear as you type.

UserService.ts
1213141516171819202122
async getUsersByIds(ids: string[]) { const results = []; for (const id of ids) { const u = await db.query("SELECT * FROM users"); results.push(u); } } function login(u, remember = false) { const k = "sk_live_4eC39Hq..."; try { auth(u, k); } catch (e) {}
✕db/query-in-loopSQL query inside a for loop — N+1 problem
✕db/no-select-starAvoid SELECT * — fetch only what you need
✕security/hardcoded-secretPossible hardcoded secret detected
!custom/empty-catchEmpty catch — error silently swallowed
icustom/boolean-paramBoolean param — use options object or split fns
What ScaleArch catches

80+ rules · 5 languages · 6 categories.

DB

Database

no-select-star · no-where-clause
query-in-loop · leading-wildcard
delete-without-where
SEC

Security

hardcoded-secret · eval-usage
shell-true · sql-concatenation
gets · strcpy · sprintf
PERF

Performance

await-in-loop · sync-fs-call
json-parse-in-loop
string-concat-in-loop
SOLID

SOLID & Quality

srp · dip · function-too-long
high-complexity · deep-nesting
too-many-params
PY-AST

Python AST

function-too-long · class-too-many
missing-docstring · no-type-hints
init-too-complex
JAVA-AST

Java AST · v2.0

empty-catch · system-exit
thread-sleep · string-equals
public-field · 8 more
02 / Rule Builder

Skip the AST tutorial.
Ship the rule.

Writing a custom lint rule from scratch means understanding tree-sitter property names, TypeScript generics, and webpack externals.

The Rule Builder eliminates that barrier. Pick a pattern. Tweak it. Test it. Copy production-ready TypeScript.

  • → 54-pattern library across 5 languages
  • → Searchable AST node picker
  • → Live regex tester
  • → "Verify with Claude" tuned prompt
  • → 6-step language-add pattern
Rule Builder
Category
database
Severity
Error
Rule ID
company/no-payment-v1
Pattern
\bPaymentV1\.\w+\(
✓ Matches your test sample (line 1)
03 / Validator

An API your CI can call before review.

POST /validate
123456
// Request { "language": "typescript", "code": "db.query('SELECT *...')" } // x-api-key: sa_live_•••
200 OK · 1 error · 3ms
1234567891011
{ "valid": false, "errorCount": 1, "errors": [{ "line": 1, "ruleId": "db/no-select-star", "severity": 0, "message": "Avoid SELECT *" }], "meta": { "rulesChecked": 62 } }
Audit logs
Every call logged. Sub-second queries by API key, time, language.
API keys
Per team or service. Expiry warnings. Instant deactivation.
Org overrides
Disable any built-in rule per org. Add custom rules through UI.
How it fits together

Two tracks. One philosophy.

Extension + Rule Builder are one product — IDE-time analysis, regex across 5 languages, AST for JS/TS/Python/Java. The Validator is a separate runtime service — its own UI, regex-only, called at save time. Same mindset, different enforcement point.

IDE-time
Author once → enforced on every keystroke
Authoring
Rule Builder
─ generates ─▶
Code
customRules.ts
─ paste ─▶
Forked + packaged
VS Code Extension
─▶
Every developer
Squigglies on save
Runtime
Author in dashboard → blocks at save time
Authoring (UI)
Validator regex rules
─ stored in ─▶
Service
POST /validate
─ called by ─▶
Org systems
Save flows · CI
─▶
Leadership
Audit log + dashboard
These tracks are independent. The Validator does not share rule code with the Extension — it supports regex only and is authored through its own dashboard, not customRules.ts.
Where it fits

Not a replacement for ESLint.
A layer above it.

ESLintSonarQubeAI reviewScaleArch
Cross-language one rulesetNoYesProbabilisticYes — 5 langs
Author rules without ASTNoNoN/AYes — Builder
Real-time IDE feedbackYesPluginPR-timeYes — <600ms
Deterministic / no AIYesYesNoYes
Works on airgapYesYesNoYes
Org governance + auditNoYesLimitedYes — Validator
CostFree$$ enterprise$ per seatFree + OSS
For organizations

Tribal knowledge → enforced standard,
in one afternoon.

A staff engineer's afternoon
14:00Fork ScaleArch
14:15Add 8 rules to customRules.ts
15:30vsce package
15:45Publish to internal marketplace
16:00Wire /validate into CI
17:00200 devs · day one · standards enforced

Real org-rule examples

company/no-raw-fetch
"Use our internal HttpClient — auth, retries, error logging built in."
company/no-payment-v1
"PaymentV1 deprecated. Migrate to V2 — see Confluence."
company/db-via-querybuilder
"All DB queries via QueryBuilder. No raw SQL strings."
All three products live today

Good code standards
should enforce themselves.

Open source · free to use · forkable for any team.

Install Extension Open Rule Builder Validator
Uday Verma · github.com/Udayverma0906 · linkedin.com/in/uday-verma0906