The Problem

Developer tooling is fragmented across terminals, editors, and file managers. Agents need context files, running code, and persistent sessions, but coordinating these across separate apps creates constant context switching. Collaborator consolidates agentic development onto a single infinite canvas where terminals, files, and code live side by side.

What This Does

Collaborator is a native macOS desktop app (Electron 40, React 19) that provides an end-to-end environment for agentic development. The main application lives in collab-electron/ with a multi-webview architecture: a navigator sidebar for file management, an infinite canvas for arranging tiles, and a viewer for file content. Terminals run through xterm.js backed by persistent tmux sessions, and code editing uses Monaco Editor.

The app is organized as an npm monorepo with packages for components (UI), shared (types and utilities), and theme. All state persists locally as JSON in ~/.collaborator/. The README states it's early-stage, macOS-only (Apple Silicon), and in active development.

How It Is Wired

Execution starts in collab-electron/src/main/index.ts (Electron main process), which imports 12 modules. The central hub is collab-electron/src/main/ipc.ts — it has 14 incoming imports and 14 outgoing ones (instability 0.93), making it the highest-traffic module. It routes renderer requests to filesystem operations in src/main/files.ts (5 modules import it) and filtering logic in src/main/file-filter.ts (6 importers, zero dependencies — a pure utility leaf).

The renderer side splits into multiple windows: src/windows/shell/src/renderer.js (1,234 lines) handles canvas rendering, src/windows/nav/src/App.tsx manages the navigator, and src/windows/viewer/src/App.tsx displays file content. The packages/components/src/TreeView/ directory owns file tree logic across 11 files, with useFileTree.ts and SearchSortControls.tsx carrying the deepest nesting. The WorkspaceGraph/ module (8 files) renders a D3 force-directed graph of workspace connections.

The import graph shows 117 internal modules with 120 edges and zero circular dependencies — a clean structure. The risk is concentration: ipc.ts and renderer.js are change hotspots where modifications ripple widely.

How To Use It

# Clone and install
git clone https://github.com/moses-y/collab-public
cd collab-public/collab-electron
npm install

# Build and run
npm run dev

The README documents a curl installer (install.sh at repo root) and prebuilt macOS releases. Configuration is minimal — the app works on local folders without accounts. Note: no lockfile is committed, so npm install won't be reproducible across environments. The bunfig.toml suggests Bun is also supported, but package.json lacks a bun.lockb.

Real-World Use

A developer working with an AI coding agent opens Collaborator, adds a workspace via Cmd+Shift+O, and drags a terminal tile onto the canvas. The agent runs in the terminal (backed by tmux for persistence), while the developer drags context files from the navigator onto the canvas as tiles. Monaco Editor tiles handle code review, and the viewer shows markdown notes with KaTeX math rendering. All sessions survive app restarts via tmux.

Code Health & Issues

Static analysis (23 findings: 13 high, 10 medium) identified four issue kinds:

  • High — Deep nesting (13 instances): TreeView/useFileTree.ts and SearchSortControls.tsx hit indentation depth 10; control flow is hard to follow. Fix: early returns and extraction.
  • High — Duplicated code (43 repeated 6-line blocks across 15 files): SourcesFeed.tsx, TreeView.tsx, shared/src/types.ts. Fix: extract shared helpers.
  • High — Oversized files (8): WorkspaceGraph/forceGraph.ts, main/workspace-graph.ts, and shell/src/renderer.js exceed 1,200 lines each. Fix: split by responsibility.
  • Medium — High branching density: shared/src/extract-cover-image.ts has 24 branch points over 54 lines.

SDLC gaps: no CI/CD pipeline (no .github/), no lockfile for reproducible builds. Tests exist (11 files), and no secrets were committed. A license is present.

The Bottom Line

A well-structured Electron app with a clean module graph and no circular dependencies, but the codebase shows signs of rapid growth — deep nesting, duplication, and oversized files will make maintenance harder. Suitable for developers who want a local-first agentic workspace and are comfortable with early-stage software; not ready for production teams needing reproducibility guarantees.