Abstract IDE

A modular, multi-console PyQt6 desktop IDE toolkit built around explicit wiring, schema-first design, and composable tab-based consoles. Each console is a self-contained tool that shares a common SharedStateBus for synchronized filter state across tabs.

Overview

abstract_ide is a collection of developer-facing GUI consoles built on PyQt6. Rather than a monolithic application, it is a registry of independently launchable consoles — each solving a specific workflow — unified under a single ideConsole shell when needed.

Included Consoles

Console	Description
Finder Console	Multi-tab file search, directory mapping, diff patching, scaffolding, and import extraction
React Runner	Build runner, TypeScript/JS function inspector, React project analyzer
API Console	API interaction tooling
Database Viewer	Tabular database inspection
ClipIt	File content clipboard manager with Python parsing
Web Pardner	Browser/web tooling
Window Manager	Desktop window management utilities
App Runner	General application launcher
Image Tab	Image viewer and management
DB Image Viewer	Database-backed image viewer
Log Console	Unified live log viewer

Architecture

Design Principles

This codebase is built around four explicit commitments:

Queues over callbacks — workers emit to signals; UI never blocks
Registries over globals — FileRegistry, SharedStateBus, and initFuncs patterns replace module-level state
Schemas over ad-hoc objects — @dataclass types (FileEntry, Config, Hunk, ApplyReport, SearchParams) define all data contracts
Explicit environment wiring — no "smart defaults" that hide dependencies; every connection is named

SharedStateBus

All tabs within a console share a SharedStateBus — a QObject-based signal broker that synchronizes filter state (directory, extensions, patterns, flags) across linked tabs. Tabs can opt out by toggling "Independent" mode.

class SharedStateBus(QObject):
    stateBroadcast = pyqtSignal(object, dict)  # (sender, state_dict)

`initFuncs` Pattern

Each tab/console uses a loader that binds free functions as instance methods at construction time, keeping class definitions thin and functions independently testable:

def initFuncs(self):
    for f in (start_search, populate_results, append_log, open_one):
        setattr(self, f.__name__, f)
    return self

ConsoleBase

All top-level consoles inherit from ConsoleBase (from abstract_gui), which provides a QMainWindow-compatible shell with a shared bus and layout entry point.

Finder Console

The primary file operations console. Launched via startFinderConsole() or embedded as a tab.

Tabs

Find Content

Full-text file search with string matching, line extraction, and result list. Runs in a QThread worker. Double-click results to open in editor.

Filters available:

Directory path (with SFTP/GVFS resolution)
Search strings (comma-separated)
Allowed/excluded extensions, types, directories, patterns
Recursive toggle, spec line, parse lines, get lines

Directory Map

Generates a visual directory tree as a list. Supports copy-to-clipboard, save-to-file, and context menu operations.

Diff (Repo)

Paste a unified diff, match hunks against files in the configured directory, preview the patched result, and apply to single or multiple files with optional backup.

Key behaviors:

Tolerant unified diff parser (works with or without @@ headers)
Per-file apply/overwrite checkboxes in results tree
save_all_checked() applies diff to all checked files with .bak backup option

Scaffolder

Paste tree-style directory structure text, parse it into TreeNode schemas, create the file/folder structure on disk, and edit file contents inline.

Uses:

TreeParser — converts tree text to TreeNode dataclass graph
ScaffoldBuilder — queue-based disk writer
FileRegistry — central in-memory registry with dirty-tracking and listeners

Extract Python Imports

Scans Python files, extracts all imports, displays as filterable "chips". Clicking an import filters the file list to files containing that import.

React Runner

TypeScript/JavaScript project tooling. Three tabs:

react Runner Tab

Runs yarn/pnpm/npm build via QProcess (non-blocking)
Streams output live to log view
Parses build errors/warnings into grouped tree views (by file, with line/col)
Embedded code editor with highlight-on-click, save, and revert
Alt-extension resolution (.ts → .tsx etc.)

Functions Tab

Scans a base path for exported TypeScript/JS functions
Three modes: Packages (dist/index introspection), Functions folder (static scan), React project (configurable subdir)
Uses @babel/parser + @babel/traverse for static analysis; falls back to regex
Displays function chips with filter; clicking shows export/import locations
Tracks both functions and variables with separate filter groups

Test Runner Tab (reactTab)

Browse packages under a configurable root
Select and call exported functions interactively with typed argument inputs
Executes via tsx through NVM-resolved Node.js
Raw JSON args override available

Installation

Requirements

Python 3.10+
PyQt6
Node.js (for React Runner — resolved via NVM automatically)

pip install abstract-ide

Or from source:

git clone https://github.com/AbstractEndeavors/abstract-ide
cd abstract-ide
pip install -e .

Dependencies

PyQt6
abstract_gui
abstract_utilities
abstract_react
abstract_apis
abstract_paths

Usage

Launch the full IDE shell

from abstract_ide.consoles import ideConsole
ideConsole.start()

Launch individual consoles

from abstract_ide.consoles.finderConsole import finderConsole
finderConsole.start()

from abstract_ide.consoles.reactRunner import reactRunner
reactRunner.start()

Embed a console as a tab

from abstract_ide.consoles.finderConsole.src.tabs.main import finderConsole
from abstract_ide.consoles.reactRunner.src.main import reactRunner

inner = QTabWidget()
inner.addTab(finderConsole(), "Finder")
inner.addTab(reactRunner(),   "React")

Use individual finder tabs directly

from abstract_ide.consoles.finderConsole.src.tabs.finderTab import finderTab
from abstract_ide.consoles.finderConsole.src.imports.share_utils.shared.inputs import SharedStateBus

bus = SharedStateBus()
tab = finderTab(bus)

Directory Structure

abstract_ide/
├── src/
│   └── abstract_ide/
│       └── consoles/
│           ├── src/
│           │   ├── main.py                    # ideConsole — top-level shell
│           │   ├── finderConsole/
│           │   │   ├── src/
│           │   │   │   ├── tabs/
│           │   │   │   │   ├── main.py        # finderConsole tab container
│           │   │   │   │   ├── finderTab/     # full-text search
│           │   │   │   │   ├── directoryMapTab/
│           │   │   │   │   ├── diffParserTab/
│           │   │   │   │   ├── scaffolder/
│           │   │   │   │   ├── collectFilesTab/
│           │   │   │   │   └── extractImportsTab/
│           │   │   │   └── imports/
│           │   │   │       └── share_utils/
│           │   │   │           └── shared/
│           │   │   │               ├── inputs.py        # install_common_inputs, SharedStateBus
│           │   │   │               ├── states/          # read_state / write_state
│           │   │   │               ├── results/         # make_params, browse_dir
│           │   │   │               └── visibility/      # visibilityMgr (collapsible sections)
│           │   └── reactRunner/
│           │       └── src/
│           │           ├── main.py            # reactRunner tab container
│           │           ├── runnerTab/         # build runner + error tree + editor
│           │           ├── functionsTab/      # JS/TS function inspector
│           │           │   ├── flowLayout/    # wrapping chip layout
│           │           │   └── functionsTab/
│           │           │       └── functions/ # scan, filter, render, log utils
│           │           ├── reactTab/          # interactive function caller
│           │           └── imports/
│           │               ├── constants.py
│           │               ├── imports.py
│           │               └── ext_funcs/
│           │                   ├── node_resolver.py   # NVM-aware Node/tsx finder
│           │                   └── path_inputs.py     # validated QLineEdit helpers
├── setup.py
├── setup.cfg
├── pyproject.toml
└── README.md

Key Modules

`SharedStateBus`

Signal broker for synchronized filter state across tabs. Tabs push state on change; linked tabs receive and apply it silently (via QSignalBlocker).

`install_common_inputs`

Single-call function that wires a full filter form (directory, strings, 8 filter fields, flags, spec_line) into any QWidget host and connects it to a SharedStateBus.

`visibilityMgr`

Collapsible section manager using QPropertyAnimation on maximumHeight. Persists open/closed state via QSettings. No adjustSize() calls — flicker-free.

`runSubProcess` / `node_resolver`

NVM-aware subprocess runner. Resolves node, npm, npx, tsx across PATH, common dirs, NVM installations, and login shell fallback. Injects correct PATH and NODE_PATH into subprocess environment.

`parse_unified_diff`

Tolerant unified diff parser. Works with or without @@ headers. Returns List[Hunk] where each hunk carries subs (lines to match) and adds (lines to insert).

`getPaths`

Finds exact contiguous string matches across a list of files. Returns (unique_files, found_paths) with line-level metadata for each match.

`TreeParser` / `ScaffoldBuilder` / `FileRegistry`

Scaffolding pipeline. TreeParser converts tree-style text to TreeNode graphs. ScaffoldBuilder uses a deque queue for ordered disk creation. FileRegistry tracks all created files with dirty state and listener callbacks.

Development

Running from source

git clone https://github.com/AbstractEndeavors/abstract-ide
cd abstract-ide
pip install -e ".[dev]"
python -m abstract_ide

Building for PyPI

python -m build
twine upload dist/*

Contributing

Fork the repository
Create a feature branch (git checkout -b feature/my-console)
Follow existing patterns: initFuncs, @dataclass schemas, QThread workers
Submit a pull request

License

MIT License. See LICENSE for details.

Contact

Abstract Endeavors partners@abstractendeavors.com https://github.com/AbstractEndeavors

Development Status
- 3 - Alpha
Intended Audience
- Developers
License
- OSI Approved :: MIT License
Programming Language
- Python :: 3
- Python :: 3.11

Metadata

Development Status
- 3 - Alpha
Intended Audience
- Developers
License
- OSI Approved :: MIT License
Programming Language
- Python :: 3
- Python :: 3.11

Release files for abstract-ide 0.0.0.404

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for abstract-ide 0.0.0.404
File	Size	Uploaded
abstract_ide-0.0.0.404.tar.gz	221.0 kB	Sep 28, 2026	Details

Release files / abstract_ide-0.0.0.404.tar.gz

Download URL	abstract_ide-0.0.0.404.tar.gz
Size	221.0 kB
Tags	Source
SHA-256 checksum How to use checksums	`3d10a3f7fce40adc6e1856cd8d85e5d086c0fd6c40852225b464cbeaf619596b`
BLAKE2b-256 checksum How to use checksums	`ac2dcfd830a050cc5077d1449888a5e94d717616f24dae340c761d9bd93569dd`
Upload date	Sep 28, 2026
Uploaded using Trusted Publishing? What is trusted publishing?	No
Uploaded via	`twine/6.2.0 CPython/3.13.11`