SHENAL DILUKSHA • SENIOR SOFTWARE ARCHITECT

Hello, I'm Shenal Diluksha.I ARCHITECT
AUTONOMOUS SYSTEMS.
SLAY BLOAT IN FLOW.

Engineering category-defining developer tools, zero-latency AST invariant radars (<50ms), and parallel reapers that reclaim gigabytes of disk debris and kill zombie dev servers.

9+
Systems Deployed
Production Repos
<50ms
Scan Velocity
AST Core Latency
120GB+
Disk Reclaimed
Bloat Slayed
100%
Test Pass Rate
Full Matrix CI
QUANTUM REACTOR
01 · LATENT CORE
⚡ HARMONICS:142 Hz
SCRUB:0%
CORE:SYNCHRONIZED
QUANTUM REACTOR: 01 · LATENT CORE
Autonomous Agents That Think Ahead
Reverse-Engineering Code DNA
Sub-50ms Blast Radius Radar
The Zero-Latency Reapers
TRANSFORMATION CINEMA
01/04|0%
PHASE 01//QUANTUM AI CORE
VEC: [0.00, 0.42, 1.84]

Autonomous Agents That Think Ahead

//Contextual Codebase Companions & Full-Stack Scaffolding

Self-directing agentic loops navigating deeply nested architectures, generating verified full-stack applications, and conducting multi-source research from single prompts.

PHASE 02//SYNTAX HELIX TUNNEL
VEC: [1.24, -0.15, 4.90]

Reverse-Engineering Code DNA

//Deep Graph Topology & Real-Time Intelligence

Mapping monolithic systems into interactive topological dependency graphs. Detecting circular imports, cyclomatic hotspots, and streaming real-time vector telemetry.

PHASE 03//OPTICAL PRISM RADAR
VEC: [0.00, 0.00, 7.32]

Sub-50ms Blast Radius Radar

//Refracting Glass Prisms & Hallucination Sanitizers

When LLMs refactor code with tunnel vision, Prism parses the AST call-graph in <50ms to detect broken downstream callers, while Sober sanitizes leaked secrets and hallucinations.

PHASE 04//OBSIDIAN RUNTIME NEXUS
VEC: [0.88, 0.24, 9.80]

The Zero-Latency Reapers

//High-Speed Edge Routing & Parallel Filesystem Sweeps

Boundary-pruned crawlers reclaiming 50GB of dev bloat in 3 seconds, killing port hogs on :3000, and single-binary edge gateways routing inferences across 20+ LLM providers.

// 01. INTERACTIVE CONSOLE

The Developer Reaper & AST Radar Terminal

Experience the tools in action without leaving your browser. Click any quick-action or type directly below.

shenald@core:~/systems
SHEN_OS v2.4
Quick Run:
❯welcome
╔═════════════════════════════════════════════════════════════════════════╗
║ SHENALD ARCHITECTURAL COMMAND DECK • v0.1.0-STABLE ║
║ Zero-Latency Systems • AST Radar Invariants • Process Reaper ║
╚═════════════════════════════════════════════════════════════════════════╝
Type 'help' or click any quick-action below to test live CLI tools.
❯
// 02. PRODUCTION ARTIFACTS

Flagship Open-Source Systems

Architected for zero bloat, flow-state productivity, and automated AI pair programming.

bonsai
Autonomous AIv0.1.0

bonsai

Zero-Knowledge Local AI Distillation on Consumer Silicon

Cultivates massive foundation models into pocket-sized intelligences (0.5B-1.5B) directly on consumer laptops. Zero-OOM guard, prompt loss masking, and built-in blind holdout proof engine.

34s Distillation
Zero-OOM Guard
Unseen Exam Proof
PythonPyTorch CUDAPEFT LoRATyperRich
purge
High-Performancev0.1.0

purge

Developer Bloat & Zombie Dev Server Reaper

Parallel disk crawler that prunes traversal at artifact boundaries and hunts orphan dev servers holding ports :3000, :5173, :8000 hostage. Reclaims 50GB in under 3 seconds.

<3.0s Multi-GB Crawl
Slay Ports :3000
Protected Roots
PythonTyperRichpsutilThreadPool
prism
High-Performancev0.1.0

prism

Topological Blast Radius & Invariant Radar

Zero-latency topological call-graph & contract invariant analyzer. Pinpoints every broken downstream caller caused by AI refactoring tunnel vision before you commit.

<50ms Pure AST
Multi-Hop Shockwave
Strict Pre-Commit
PythonTyperAST EngineRichDAG Graph
sober
High-Performancev0.1.0

sober

The Vibe Coding Hangover Cure

Ultra-fast zero-config auditor and sanitizer. Detects AI hallucinations, ghost code, leftover debug statements, and leaked secrets before pushing to production.

<500ms Sanitizer
Slopsquatting Shield
Auto-Cure Residue
PythonTyperRichASTPyPI Registry
SHEN AI
Autonomous AI

SHEN AI

Autonomous Coding Agent & Pair Programmer

A next-generation multi-agent coding companion that thinks ahead, navigates deep codebases, learns developer style, and writes production code inside VS Code.

Multi-Agent Loop
Context Memory
Zero-Latency Stream
TypeScriptReactAnthropic ClaudeOpenAIVS Code API
AgentForge
Autonomous AI

AgentForge

Autonomous Full-Stack App Builder

Give it a single prompt and watch it scaffold a production Next.js frontend, FastAPI backend, Dockerized orchestration, and GitHub Actions CI/CD pipelines instantly.

One-Prompt Generation
Docker & CI/CD Ready
Clean Architecture
TypeScriptHandlebarsOpenRouter APIFastAPI
one-api
Infrastructure

one-api

Universal Edge LLM Gateway

Single-binary, zero-config API gateway routing inferences across 20+ top-tier LLM providers with automatic fallback, load balancing, and token rate limiting at the edge.

Sub-10ms Routing
20+ LLM Providers
Zero-Config Binary
TypeScriptHono.jsVercel EdgeCloudflare Workers
CodeDNA
Dev Intelligence

CodeDNA

Software Intelligence Analyzer

Reverse-engineers any codebase to generate interactive "DNA profiles", visualizing architecture, circular dependencies, cyclomatic hotspots, and developer patterns.

Architectural Maps
Hotspot Profiling
Interactive DNA
PythonNetworkXMermaidGraphViz
AutoResearch Agent
Autonomous AI

AutoResearch Agent

Modular Deep-Dive Research Agent

Intelligent CLI agent powered by LangChain that scours scholarly archives and the live web to generate synthesis reports with verifiable source citations.

Multi-Step Synthesis
Verified Citations
Automated Markdown
TypeScriptLangChainOpenAITavily
Catalyst
Infrastructure

Catalyst

Parallel DAG Workflow Engine

Executes highly complex data pipelines using strictly-typed Domain-Driven Design in Python. Includes micro-benchmarks, dependency graph validation, and task queuing.

DAG Parallelism
Strict Typing
Zero-Allocation Core
PythonFastAPINetworkXPydantic
System Blueprint & Topology

The Full-Stack Flow Engine

A synchronized tripartite architecture combining autonomous multi-agent creation, sub-50ms AST contract radar, and zero-bloat runtime reapers.

PHASE 01Multi-Agent Systems

Autonomous Intelligence

Autonomous coding loops, contextual agents, and full-stack generative scaffolding that understand complex codebases.

SHEN AIAgentForgeAutoResearch
PHASE 02Safety & Contracts

Invariant & AST Radar

Sub-50ms AST topological graph traversals to ensure AI agents never break downstream callers or leak credentials.

prismsoberCodeDNA
PHASE 03Performance & Flow

Zero-Bloat Reapers

Parallel filesystem reapers and socket hunters that keep dev machines clean, freeing gigabytes of bloat and killing dead ports.

purgeone-apicatalyst
Active Layer: Autonomous Intelligence

Autonomous agents construct complex software topologies from single prompts with verified domain models.

// 03. TECHNICAL CAPABILITIES

Architectural Domain Matrix

Languages, agent loops, and execution runtimes engineered with obsessive craft.

Systems & Languages●

TSTypeScript
Senior Architect
PYPython
Performance Specialist
RSRust / Cargo
Systems & Memory
SHBash & POSIX
Automation

AI & Autonomous Agents●

🤖Multi-Agent Architectures
Advanced
🧠Anthropic / Claude API
Core Tooling
🧬LangChain & Vector DBs
Memory & RAG
⚡OpenRouter & Edge Models
Orchestration

Architecture & Infrastructure●

⚛️Next.js & React 19
UI Engine
🚀FastAPI & Hono.js
Edge Microservices
🐳Docker & CI/CD
Production Matrix
🔬AST Parsers & Compilers
Invariant Analysis
PRINCIPAL ARCHITECT OVERVIEW & OPEN-SOURCE ECOSYSTEM

About Shenal Diluksha

Colombo, Sri Lanka • Remote Global Architecture • Open-Source Creator (shenald-dev)

I am Shenal Diluksha (known across open-source as shenald-dev), a Senior Software Architect, systems designer, and creative vibe coder building zero-latency developer infrastructure, compiler AST invariant radars, and autonomous multi-agent AI systems.

My engineering philosophy is rooted in Zero Bloat and Maximum Flow: turning coffee and flow state into strictly-typed, sub-50ms execution engines. When AI writes code at 1,000 WPM, traditional tools introduce crippling drag, hallucinated bugs, and disk debris.

Rather than building trivial AI wrappers, I engineer foundational systems that empower developers: high-speed guardians like prism (sub-50ms topological blast radius radar), purge (parallel filesystem reaper & zombie server hunter), and sober (vibe coding hallucination sanitizer), alongside autonomous multi-agent platforms and edge gateways.

ARCHITECTURAL CAPABILITIES⚡ 100% PRODUCTION READY
  • ❯Multi-Agent Orchestration: Self-directing coding companions with persistent vector memory.
  • ❯AST & Call-Graph Parsing: Sub-50ms invariant shockwave analysis & contract safety.
  • ❯High-Performance Reapers: Boundary-pruned parallel crawlers saving 50GB disk in 3s.
  • ❯Edge Gateways: Sub-10ms unified routing across 20+ LLM providers with automatic fallback.

// THE COMPLETE SHENAL DILUKSHA OPEN-SOURCE PORTFOLIO

9 ACTIVE REPOSITORIES
PILLAR 01🤖

Autonomous AI Agents

Self-directing agents that think ahead, write full-stack code, and synthesize deep academic research.

PILLAR 02🧬

Software Intelligence

Topological graph modeling, circular dependency analysis, and quantitative market intelligence.

PILLAR 03🛡️

AST Invariant Radars

Sub-50ms topological call-graph guardians that detect AI refactoring breakage and slopsquatting.

PILLAR 04⚡

Zero-Bloat Reapers & Edge

Parallel filesystem sweepers reclaiming 50GB and single-binary sub-10ms edge LLM gateways.

// 05. ARCHITECTURAL KNOWLEDGE BASE & FAQ

System Dossier & Architecture Insights

Frequently referenced inquiries on engineering philosophy, open-source developer tooling, and technical invariants.

Shenal Diluksha is a Senior Software Architect, AI Systems Engineer, and Creative Vibe Coder. He specializes in designing deterministic software systems, microsecond developer tooling, and autonomous multi-agent frameworks that eliminate enterprise bloat and establish compile-time AST invariants.

#Shenal Diluksha#Senior Software Architect#AI Engineer#Sri Lanka
DIRECT SECURE TRANSMISSION

Connect With Shenal Diluksha

Whether you need a principal software architect to design an autonomous multi-agent system, optimize high-throughput distributed pipelines, or build category-defining developer tools — let's talk.

SHENAL DILUKSHA•COLOMBO / REMOTE GLOBAL•COLLABORATIONS: OPEN