developer-toolsaiopen-sourcedesktop

OraFlow: Developer Productivity Through Local AI and Code Graph Analysis

Tawakkul Labs · 15 May 2026

Summary

Flutter desktop productivity suite integrating static code scanning, WebSocket-based VS Code extension, and local semantic analysis. Demonstrates that real-time developer tooling can run on-device without cloud inference.

View on GitHub

Introduction

OraFlow is an intelligent developer productivity suite that combines a Flutter desktop application with a VS Code extension working over a local WebSocket connection. It provides real time error detection, AI powered code analysis, and one click fix suggestions inside a modern, cockpit inspired interface.

The design thesis is deliberately contrarian. Most developer tools treat cloud inference as the default and the local model as a fallback. OraFlow inverts that: the primary analysis path runs entirely on your machine, with cloud AI reserved as an optional fallback for low resource setups. The result is a tool whose responsiveness does not depend on network latency, subscription quotas, or where you happen to be working.

Features

Core Features

  • WebSocket Communication. Real time bidirectional communication between the Flutter desktop app and VS Code.
  • Automatic Error Detection. Monitors code in real time and detects errors as you type.
  • AI Code Analysis. Local analysis that understands code context and suggests improvements.
  • One Click Fixes. Applies generated fixes with a single click.
  • Knowledge Graph. Visual representation of code relationships and dependencies.
  • Health Monitor. System resource monitoring for optimal performance.
  • Activity Log. Comprehensive logging of all operations and events.
  • Resource Guard. Automatic RAM monitoring with an optional cloud AI fallback for low resource machines.

Additional Features

  • A custom title bar with the cockpit inspired UI.
  • A file inspector for detailed file analysis.
  • A semantic analyzer for deep code understanding.
  • A status bar showing connection and system state in real time.
  • Error badges as visual indicators for code issues.
  • A dashboard acting as the central hub for all activity.

Architecture

OraFlow is a small system by design: one desktop app, one extension, and one optional auxiliary server, all connected over a single local WebSocket channel.

           ┌────────────────────────────────────────────────────────────────────────┐
           │                             OraFlow System                             │
           │                                                                        │
           │ ┌────────────────────────┐                  ┌────────────────────────┐ │
           │ │    Flutter Desktop     │                  │    WebSocket Server    │ │
           │ │          App           │◄──WS────────────►│    (localhost:6543)    │ │
           │ │                        │                  │                        │ │
           │ └────────────────────────┘                  └────────────────────────┘ │
           │              ┴───────────────────────────────────────────┴             │
           │ ┌────────────────────────┐                  ┌────────────┬───────────┐ │
           │ │        VS Code         │                  │      MCP Servers       │ │
           │ │       Extension        │                  │      (adb_bridge)      │ │
           │ │    (oraflow_bridge)    │                  │                        │ │
           │ └────────────────────────┘                  └────────────────────────┘ │
           │                                                                        │
           └────────────────────────────────────────────────────────────────────────┘

The Flutter app owns the conversation. It starts a WebSocket server on localhost port 6543, and the VS Code extension connects to it automatically. The extension sends code context; the desktop app scans, analyzes, and returns errors and fixes over the same channel. The MCP server layer extends the system to new integrations, beginning with an ADB bridge for Android development.

Because the server lives inside the desktop app, there is no middleware to deploy, no cloud round trip, and no data leaving the machine during normal use.

Technology Stack

  • Desktop App. Flutter 3.0+.
  • Extension. TypeScript 4.x.
  • Runtime. Node.js 16+.
  • Communication. WebSocket, RFC 6455.
  • UI Framework. Material Design 3.0.

Project Structure

The repository is organized into three cooperating projects:

ORAFLOW/
├── README.md # This file
├── flutter/ # Flutter SDK (submodule)
│ ├── bin/
│ ├── packages/
│ └── ...
│
├── oraflow_desktop/ # Main Flutter Desktop Application
│ ├── lib/
│ │ ├── main.dart # Entry point
│ │ ├── screens/ # Screen widgets
│ │ │ └── dashboard.dart # Main dashboard
│ │ ├── services/ # Business logic services
│ │ │ ├── bridge_service.dart # WebSocket client
│ │ │ ├── scanner_service.dart # Code scanner
│ │ │ ├── semantic_analyzer_service.dart
│ │ │ └── resource_guard_service.dart
│ │ └── widgets/ # Reusable UI components
│ │ ├── knowledge_graph_view.dart
│ │ ├── health_monitor.dart
│ │ ├── file_inspector.dart
│ │ ├── status_bar.dart
│ │ ├── activity_log.dart
│ │ └── error_badge.dart
│ ├── pubspec.yaml # Dependencies
│ └── build/ # Build outputs
│
├── oraflow_bridge/ # VS Code Extension
│ ├── src/
│ │ ├── extension.ts # Main extension logic
│ │ └── preview_handler.ts # Preview handling
│ ├── package.json # Extension metadata
│ └── .vscode/ # VS Code config
│
└── mcp_servers/ # MCP Server Implementations
 ├── adb_bridge.py # ADB bridge server
 ├── requirements.txt # Python dependencies
 └── setup_adb_bridge.bat # Setup script

Getting Started

Prerequisites

  • Flutter SDK. 3.0+ required, latest stable recommended.
  • VS Code. 1.70+ required, latest recommended.
  • Node.js. 16+ required, 20 LTS recommended.
  • npm. 8+ required, latest recommended.
  • Git. 2.30+ required, latest recommended.

Installing Flutter. Download Flutter from flutter.dev, extract the archive, add it to your system PATH, and verify with flutter doctor.

Enabling Desktop Support.

flutter config --enable-windows-desktop
flutter config --enable-macos-desktop
flutter config --enable-linux-desktop

Installation

Clone the repository and set up each component in turn.

git clone https://github.com/AbduljabbarBXR/Oraflow.git
cd Oraflow

Initialize the repository if needed:

git remote add origin https://github.com/AbduljabbarBXR/Oraflow.git
git branch -M main

Build the Flutter desktop app:

cd oraflow_desktop
flutter pub get
flutter build windows

Compile the VS Code extension:

cd oraflow_bridge
npm install
npm run compile

Running the App

Run the desktop app, then launch the extension in VS Code with the debugger.

cd oraflow_desktop
flutter run -d windows

For development with hot reload:

flutter run -d windows --debug

Open the oraflow_bridge folder in VS Code, press F5 to launch the extension debugger, and the extension connects to the running Flutter app automatically.

Components

Flutter Desktop App

The main application is built with Flutter and owns the analysis pipeline:

  • A custom window manager with a frameless window and custom title bar.
  • A built in WebSocket server on port 6543 using Dart’s HttpServer.
  • A modular service layer, one service per responsibility.
  • A reusable widget library for the dashboard, graph, and monitor views.

Key Services

  • BridgeService manages WebSocket connections.
  • ScannerService scans and analyzes code files.
  • SemanticAnalyzerService performs deep code analysis.
  • ResourceGuardService monitors and manages system resources.

VS Code Extension

The extension, named oraflow_bridge, is the editor side of the system:

  • Automatic WebSocket connection to the Flutter app.
  • Real time error detection and display.
  • Code fix suggestions with diff preview.
  • Status click fix notifications inside VS Code.

Extension Commands

  • oraflow.connect to connect to OraFlow.
  • oraflow.disconnect to disconnect from OraFlow.
  • oraflow.analyze to trigger code analysis.
  • oraflow.applyFix to apply the suggested fix.

MCP Servers

Model Context Protocol server implementations extend the system to new surfaces. The first integration is the ADB bridge, connecting Android development workflows to the analysis pipeline.

How It Works

The system is delivered in four phases that are now all live.

Phase 1: WebSocket Heartbeat

The Flutter app starts a WebSocket server on localhost port 6543. The VS Code extension connects automatically and shows a connection notification. A test button verifies the channel with a ping and pong exchange.

Phase 2: Shadow Terminal

A background scanner watches code changes. Error detection flags issues in real time, and a shadow log records detected errors with details, so nothing is silently lost.

Phase 3: Agent Logic

Analysis sends code to the local analysis agent, which produces fix suggestions as old and new code diffs. One click applies the fix directly into the open editor.

Phase 4: Full UI

The knowledge graph visualizes code relationships, the health monitor tracks system performance, and the dashboard ties everything together in one view.

Phases of Development

  • Phase 1: WebSocket Heartbeat, Complete. Basic WebSocket communication.
  • Phase 2: Shadow Terminal, Complete. Error detection and logging.
  • Phase 3: Agent Logic, Complete. AI analysis and fix suggestions.
  • Phase 4: Full UI, Complete. Knowledge graph, health monitor, dashboard.

Configuration

Flutter Configuration

The desktop app reads oraflow_config.json:

{
 "websocket_port": 6543,
 "log_level": "info",
 "enable_ram_monitoring": true,
 "ram_threshold_mb": 8192,
 "fallback_to_cloud_ai": true
}

The last two settings are the Resource Guard. When RAM pressure crosses the configured threshold, the system can route analysis to the cloud fallback rather than grinding to a halt.

VS Code Extension Configuration

The extension is configured through VS Code settings:

{
 "oraflow.serverUrl": "ws://localhost:6543",
 "oraflow.autoConnect": true,
 "oraflow.showNotifications": true
}

Troubleshooting

1. WebSocket Connection Failed

The extension cannot reach the Flutter app. Ensure the app is running, check that port 6543 is free, and verify firewall settings.

# Check if port is in use
netstat -an | findstr 6543

2. Flutter Desktop Not Supported

Desktop support is not enabled. Enable it and verify:

flutter config --enable-windows-desktop
flutter doctor

3. Extension Not Loading

The extension fails to start. Rebuild it:

cd oraflow_bridge
npm install
npm run compile

4. RAM Issues

The app is consuming too much memory. Enable the Resource Guard, lower the RAM threshold, or allow cloud AI fallback for the heaviest analyses.

Contributing

Contributions are welcome. Review the contributing guidelines before submitting pull requests.

Development Workflow

  1. Fork the repository.
  2. Create a feature branch.
  3. Commit your changes with a descriptive message.
  4. Push the branch to your fork.
  5. Open a Pull Request.

License

This project is licensed under the MIT License. See the LICENSE file for details.

Acknowledgments

Special thanks to the Flutter team for the framework, the VS Code team for the extensible editor, and every contributor and tester who has shaped the project.