DEV Community: SWAGAT SOURAV DHAR

DocuMorph: Living 3D Architecture Constellations & Interactive API Sandboxes

SWAGAT SOURAV DHAR — Sat, 31 Oct 2026 08:05:53 +0000

🧬 DocuMorph: Living 3D Architecture Constellations & Interactive API Sandboxes

Every engineering team knows the dread of documentation drift: you design an architecture diagram, write API specifications, and within three weeks the code evolves while the documentation quietly rots. Architecture diagrams in Confluence or Eraser stay static, while developers scramble across Swagger tabs and Postman collections just to see if an endpoint actually behaves the way the docs claim.

DocuMorph was built to solve this once and for all: transforming raw code, GitHub links, and API specifications into living, interactive documentation with dual 2D/3D WebGL architecture constellations and an executable API sandbox directly on the canvas.

🌟 The Core Innovations

1. 🌌 Dual-Engine Architecture: 2D React Flow + 3D WebGL Constellations

Most diagramming tools are stuck in flat 2D box-and-arrow formats. DocuMorph features a dual visual engine:

Interactive 3D WebGL Hologram Constellation: Built with Three.js, OrbitControls, and custom particle glow shaders. Microservices, databases, and gateways form a living 3D constellation with real-time animated data-packet flows and card perspective tilt.
2D React Flow Canvas: A precise, zoomable topological canvas with node-level edge routing, status indicators, and payload inspectors.
Seamlessly toggle between 2D and 3D with mode memory.

2. ⚡ Enterprise Code Link Ingestion with Hardened Security

Rather than forcing users to manually copy-paste code or install invasive repo-level daemon hooks, DocuMorph provides an Enterprise Code Link Ingestor:

Paste any GitHub repository URL, raw code link, or spec.
SSRF & Private IP Blocking: Actively filters out requests targeting 127.0.0.1, localhost, 10.x.x.x, 192.168.x.x, or private subnets to prevent SSRF proxy abuse.
Sliding-Window Rate Limiting: Enforces strict 10 requests/minute per IP.
XSS & AST Sanitization: Input is validated through strict Zod schemas and sanitized before being processed into state.

3. 🧪 Living API Sandbox & Monaco Editor

Click on any service or endpoint node in either 2D or 3D view to immediately open the Living API Sandbox.
Execute mock and live requests, test custom JSON payloads, and inspect status codes in real time with client-side sandboxing.
Embedded Monaco Code Editor (VS Code-grade syntax highlighting and diffing) lets developers inspect the underlying implementation without leaving the canvas.

4. 📊 Observability & Telemetry (Grafana Metrics)

Integrated real-time telemetry modal simulating Grafana-style service observability: latency percentiles (p50, p95, p99), throughput graphs, error stream logs, and node health indicators.

5. 📦 Universal Spec Export

Export the living state at any time into standard OpenAPI 3.1 specs, JSON Schemas, or GitHub-flavored Markdown.

🛠️ The Tech Stack

Framework: Next.js 16 (App Router) + React 19.3.1 + TypeScript
3D Graphics: Three.js WebGL Engine + OrbitControls + High-Precision performance.now() clocking
2D Graph Topology: React Flow (@xyflow/react)
Code Editor: Monaco Editor (@monaco-editor/react)
Validation & Security: Zod schemas, DOMPurify overrides, Sliding-Window in-memory rate limiting
Package Management & Tooling: pnpm 11, Node 22 LTS, CodeQL static security analysis

🔗 Links & Resources

GitHub Repository: https://github.com/SWAGAT10241/documorph
GitHub Wiki: https://github.com/SWAGAT10241/documorph/wiki
Built for: Hacktoberfest 2026 & Open-Source AI Developer Ecosystem

Built with passion for open-source developer tooling and living system architecture.

Haunted Shell: Possessing Your Terminal with Local Open-Weight AI (Ghost in the Machine)

SWAGAT SOURAV DHAR — Fri, 30 Oct 2026 13:18:47 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge: Week 4 - Ghost in the Machine.

What I Built & How I Interpreted the Theme

For this week's "Ghost in the Machine" theme, sitting right between Halloween and Día de los Muertos, I wanted to take the concept literally: What if a supernatural spirit lived inside your terminal, directly possessing your shell?

Introducing haunted-shell — an open-source, production-grade, local-first possessed terminal companion.

Whenever you run a command in your everyday shell (rm -rf, git push --force, kill -9, cat, whoami), an eerie spirit materializes, analyzing your command, exit code, and environment to whisper spooky commentary, roast dangerous commands, compose satirical calaveritas literarias in honor of computing ancestors, or scan the operating system's process table for real defunct zombie processes to exorcise.

To bridge Halloween and Día de los Muertos, haunted-shell comes with three distinct spirits:

The Poltergeist (poltergeist): A mischievous, chilling Halloween ghost who laughs at segfaults, mourns deleted inodes in /dev/null, and warns you of entities dwelling in ring 0.
La Calavera (calavera): A warm, philosophical Día de los Muertos spirit who scatters marigold (cempasúchil) petals on deleted files and writes witty poetic verses celebrating computing pioneers (Ada Lovelace, Grace Hopper, Alan Turing).
The 1971 PDP-11 Mainframe Specter (unix-elder): An ancient Bell Labs Unix ghost horrified by 80,000-file node_modules folders and multi-gigabyte browser memory leaks, longing for teletypes, pipes, and reel-to-reel magnetic tape.

Why Open Innovation Matters for `haunted-shell`

The challenge asks: Why does open innovation matter for what you built?

For a shell companion, open-source AI and local inference are not just nice-to-haves—they are an absolute security and functional prerequisite.

Absolute Air-Gapped Privacy for Shell Secrets: Your terminal is the most sensitive surface on your entire computer. It holds private SSH keys (~/.ssh), API tokens, environment variables ($AWS_SECRET_ACCESS_KEY), internal IP addresses, and proprietary code. If this tool were powered by a closed commercial cloud API (like OpenAI or Anthropic), every single command and argument would be transmitted across the internet to a third-party server. By using open-weight models (like Google Gemma 2) running entirely locally on-device, zero telemetry or command data ever leaves the laptop.
Works With the Lights (and the Internet) Off: Whether you are coding in an airplane cabin at 35,000 feet, in a remote server room, or during a storm with the WiFi down, haunted-shell doesn't skip a beat. It has zero cloud dependencies, zero external latency, and zero rate limits.
No Subscription Costs or Billing Meters: Developers type hundreds or thousands of shell commands every day. Routing those through paid proprietary cloud APIs would burn money. With local open-weight models, inference is 100% free forever.
Resilience & Custom Persona Freedom: Closed APIs suffer from sudden model deprecations and unpredictable system prompt overrides. Open weights can be fine-tuned, modified, and saved locally forever.

Demo & Live Experience

1. Interactive Possession Shell

Running haunt shell launches a possessed subshell with persistent readline history and directory tracking:

      .-.
     (o o) boo!
     | O \
      \   \      G H O S T   I N   T H E   M A C H I N E
       `~~~'     [ Possessed by local open-weight AI. Air-gap verified. ]

👻 Spirit: The Poltergeist of Purgatory
🔒 Air-gap Security: Verified Local-Only (Local Open-Weight Model [gemma2:2b])
💡 Type regular commands or ':help' for builtins. Type 'exit' to escape.

[haunted-shell] 👻 rm -rf old_drafts.txt
  👻  Gone. Banished to /dev/null. But in the graveyard of your disk, their sectors still whisper.

[haunted-shell] 👻 kill -9 4120
  👻  A cold-blooded slaughter... PID 4120 extinguished in an instant. Its orphan spirit lingers in kernel space.

[haunted-shell] 👻 git push --force origin main
  👻  You tear the fabric of shared memory without remorse. May the merge conflicts haunt your dreams.

2. Día de los Muertos Calaveras

Switching to --persona calavera (or typing :persona calavera live in the shell) turns your terminal into a remembrance altar:

[haunted-shell] 💀 git commit -m "Refactor parser"
  💀  Estaba la Catrina sentada en el disco / viendo tus commits con sonrisa y pellizco:
      '¡No te apures, dev, por ese merge conflict / que en el camposanto todo queda fixed!'

3. Real OS Zombie Process Exorcism with Safety Guardrails

haunt exorcise inspects the host operating system's kernel process table using psutil, hunting for true zombie processes, orphaned daemons, and memory-devouring wraiths, with built-in protections preventing accidental termination of PID 1 or host shells:

$ haunt exorcise
┌─[ SPECTRAL PROCESS NECROPSY ]────────────────────────────────────────────────────┐
│ Detected 3 restless entity/entities lurking in memory:                           │
│                                                                                  │
│ • PID 34646 [Memory Wraith] - Code Helper (Renderer)                             │
│   Memory: 200.7 MB | Age: 36.2 mins                                              │
│   "Devours 200.7 MB of physical memory like a restless devourer."                │
│                                                                                  │
│ • PID 41047 [Shadow Daemon] - language_server                                    │
│   Memory: 201.7 MB | Age: 8.3 mins                                               │
│   "Spawned in haste, abandoned in cold memory. It wanders kernel space..."       │
└──────────────────────────────────────────────────────────────────────────────────┘

To banish a restless PID, run: haunt exorcise --banish <PID>

4. Universal Shell Hooks (Zsh, Bash & Fish)

You don't even need to stay in a subshell. With haunt hook, your everyday terminal prompt automatically inherits the possession on every command you execute:

# For Zsh (~/.zshrc):
eval "$(haunt hook zsh)"

# For Bash (~/.bashrc):
eval "$(haunt hook bash)"

# For Fish (~/.config/fish/config.fish):
haunt hook fish | source

5. Environment Diagnostics (`haunt doctor`)

haunt doctor performs a rapid health audit of the host system, checking local Ollama connectivity, downloaded open-weight models, terminal color capability, and configuration status:

$ haunt doctor
┌─[ HAUNTED-SHELL SYSTEM DIAGNOSTICS ]─────────────────────────────────────┐
│ Platform: Darwin 27.2.0 (arm64)                                          │
│ Python:   3.14.3 (✓ Supported)                                           │
│ Terminal: Interactive TTY | Colors: ✓ Enabled | Size: 80x24              │
│                                                                          │
│ Active Persona:  poltergeist                                             │
│ Configured Model: gemma2:2b                                              │
│ Config File:      ~/.config/haunted-shell/config.json (Using Defaults)   │
│                                                                          │
│ Local AI Server (http://localhost:11434):                                │
│   ✓ Ollama reachable (1 model(s) available)                              │
│     Available: gemma2:2b                                                 │
└──────────────────────────────────────────────────────────────────────────┘

Technical Architecture & How It Works

haunted-shell was designed with clean Unix philosophy, strict typing, and resilient offline degradation:

┌────────────────────────────────────────────────────────┐
│                   User Shell Command                   │
└───────────────────────────┬────────────────────────────┘
                            │
              ┌─────────────▼─────────────┐
              │    Subprocess Execution   │
              └─────────────┬─────────────┘
                            │ (Exit code, CWD, Command tokens)
              ┌─────────────▼─────────────┐
              │       GhostEngine         │
              └──────┬─────────────┬──────┘
                     │             │
        (If available)             (Air-gapped fallback)
                     │             │
        ┌────────────▼──────┐   ┌──▼──────────────────────────┐
        │ Local Open-Weight │   │ Offline Spectral Engine     │
        │ Model (Gemma 2 via│   │ (Contextual matrices,       │
        │ Ollama/llama.cpp) │   │ calaveritas & glitch-zalgo) │
        └───────────────────┘   └─────────────────────────────┘

Open-Weight Model Integration: Connects out of the box to local open-weight models (like Google Gemma 2:2B or Llama 3.2) hosted locally via Ollama (http://localhost:11434) or any local OpenAI-compatible endpoint.
Zero-Dependency Fallback Engine: If no local model server is currently active, it automatically falls back to an offline semantic and poetic generator, ensuring it runs instantly on any machine with zero setup friction.
Production Codebase:
- Complete PEP 561 typing with py.typed and zero mypy errors.
- Formatted and linted with Ruff.
- Comprehensive unit test suite (59 tests passing, >75% coverage).
- XDG configuration management (~/.config/haunted-shell/config.json).
- GitHub Actions CI matrix testing across Ubuntu and macOS.

Partner Category Consideration

Best Use of Gemma: Designed natively to run with Google's open-weight Gemma 2 (gemma2:2b / gemma2:9b), taking full advantage of Gemma's high instruction-following efficiency on consumer laptops!

Code Repository

The project is completely open source under the MIT license:

👉 GitHub: haunted-shell

Happy Halloween and ¡Feliz Día de los Muertos! May your terminals stay spooky and your memory leaks find peace.

Meet LazyPilot: An AI that works so I don’t have to.

SWAGAT SOURAV DHAR — Fri, 23 Oct 2026 16:34:04 +0000

We spend far too much time doing repetitive digital work: sorting files, renaming documents, reading long reports, and organizing information.

So, for International Sloth Day, I’m exploring a different approach: what if our computers could take care of the boring parts for us?

LazyPilot is a local-first AI assistant designed to automate repetitive tasks using open-weight models and open-source tools.

The idea is simple:

Let AI understand and categorize documents.
Automate repetitive organization tasks.
Generate useful summaries.
Keep the user in control of important changes.

Why open AI?

Open innovation makes it possible to build tools that users can inspect, customize, and run on their own machines. With local inference, private documents can stay local, and the core functionality can work without a constant connection to a hosted AI service.

The goal isn’t to replace human judgment. It’s to eliminate unnecessary busywork so people can spend their energy on things that matter.

Build once. Automate the boring stuff. Embrace your inner sloth.

OpenSourceAI #LocalAI #OpenWeights #AI #BuildInPublic #InternationalSlothDay

LocalScribe AI

SWAGAT SOURAV DHAR — Sat, 17 Oct 2026 17:36:17 +0000

I built LocalScribe AI: A private, local-first AI assistant for receipts and invoices.

Freelancers and small businesses shouldn’t have to spend hours organizing receipts and invoices. But sending sensitive financial documents to external AI services isn’t always desirable, and API costs can add up.

So I’m building LocalScribe AI, an AI-powered document organizer that runs locally.

What it does

Extracts information from receipts and invoices.
Categorizes expenses.
Flags uncertain fields for human review.
Organizes records into a searchable table.
Exports validated data to CSV.

Why open-source AI?

The model is a core part of the application, not just an API call hidden behind a user interface.

By using a compatible open-weight model with local inference, LocalScribe AI can process documents without relying on an external AI API for its core functionality.

That means greater control over sensitive data, no per-request AI API fees, and the flexibility to experiment with different models.

The trade-offs are real: local inference requires suitable hardware, and extraction accuracy still needs to be tested.

Who is it for?

Freelancers, consultants, and small businesses that need a simpler way to organize financial documents.

What I’m testing

Can a local AI workflow save someone enough time to become a product they’d actually pay for?

My next step is to put the prototype in front of a real user, measure the results, and improve it based on their feedback.

Built with: React, Python, FastAPI, Ollama, an open-weight language model, OCR, and SQLite.

I’ll share the working demo, source code, and real user feedback as the project develops.

Open innovation matters when it gives people more control over their tools, their data, and the economics of using AI.

Built an Offline Frost Predictor with TabPFN-v2 and Gemma 3 (No Internet, No API Keys)

SWAGAT SOURAV DHAR — Fri, 09 Oct 2026 16:23:42 +0000

Gardeners often need planting advice where cell service is unreliable or nonexistent. To solve this, I built FrostWise, a local-first gardening assistant designed for the Hacktoberfest Open-Source AI Challenge.

Architecture
TabPFN-v2 (Tabular Foundation Model): Evaluates local weather history (ERA5 minimum daily temperatures) to forecast first and last frost dates without relying on generic hardcoded zone charts.
Gemma 3 (via Ollama): Translates predicted freeze risks into practical planting schedules and crop protection guidance.

Everything runs entirely on your local machine—no remote telemetry, no external API calls, and zero ongoing costs.

📺 Video Walkthrough: https://youtu.be/7gHYehieEnQ

Feedback and contributions are welcome!