Signal Box

A local-first AI inbox that turns developer brain-dump into project memory and shipping artefacts.

Signal Box is not a general notes app, journal, task manager, or wellness tool. It is a private thinking inbox for developers and builders: capture rough context, distil it into structured project memory, then generate useful development artefacts from it.

The alpha workflow is implemented and verified:

Capture -> Distil -> Attach to project -> Generate artefact -> Reuse later

The desktop app supports quick capture, local SQLite storage, BYOK AI distillation, project memory, artefact generation, semantic search, grounded ask, project recall, and local backup export.

Developer context decays before it becomes useful.

Developers and technical builders collect useful fragments all day:

• half-formed product ideas
• GitHub links
• copied error messages
• implementation plans
• architecture decisions
• AI prompts
• code snippets
• call notes
• comparison research
• product copy fragments
• abandoned side-project thoughts

The problem is not note-taking. The problem is turning scattered context into something shippable before the rationale disappears.

Signal Box is built around this loop:

Capture -> Distil -> Attach to project -> Generate artefact -> Reuse later

Signal Box turns raw captures into structured developer outputs:

• implementation plans
• architecture decision records
• coding-agent prompts
• product briefs
• blog or LinkedIn drafts
• project memory

Future artefact types may include GitHub issue drafts, PR descriptions, technical specs, changelogs, release notes, research briefs, and comparison notes.

The core job-to-be-done is:

I have scattered context. Help me turn it into something shippable.

A raw dump of context. This might be typed text, pasted notes, a URL, an error message, terminal output, an AI chat excerpt, a code snippet, or meeting fragments.

Important principle:

Never destroy the raw thought. Add structure beside it.

The main organizing unit. Each project has living memory: what it is, current direction, key decisions, open questions, captures, sources, and generated artefacts.

A structured record of a technical or product decision, including context, alternatives, rationale, and trade-offs. Signal Box should make it easy to produce lightweight ADRs from messy notes.

The output layer. Signal Box should always ask: what can this become?

Initial artefact types:

1. Product brief
2. Implementation plan
3. Architecture decision record
4. Coding-agent prompt
5. LinkedIn or blog draft

External or pasted context linked to captures, projects, decisions, and artefacts. Sources can include docs pages, repos, articles, PDFs, AI chat exports, screenshots, copied messages, or terminal output.

The alpha validates one complete workflow:

1. Capture rough text with a global hotkey.
2. Store raw captures locally.
3. AI-process captures into structured objects.
4. Attach captures and extracted objects to projects.
5. Maintain editable project memory.
6. Generate the five initial artefact types.

Must-have capabilities:

• Tauri desktop app
• global hotkey
• dedicated quick-capture popover window
• SQLite storage
• Drizzle schema and migrations
• inbox of unprocessed captures
• projects
• unassigned capture state with suggested project assignment
• AI processing button
• BYOK provider settings for OpenAI/OpenRouter-compatible APIs and local Ollama
• extraction of title, summary, type, tasks, decisions, open questions, and suggested project
• saved structured objects
• basic semantic search using embeddings
• project memory page
• artefact generation from selected context

Explicitly out of scope for v1:

• sync
• mobile apps
• teams
• calendar integration
• full browser extension
• passive OS-level capture
• full file watcher
• complex markdown editor
• graph view
• plugin marketplace
• task manager replacement

This repo is a Tauri + TypeScript + React app.

Implemented stack:

• Tauri
• React
• TypeScript
• Tailwind CSS
• shadcn/ui with Radix primitives
• SQLite
• Drizzle
• OpenAI/OpenRouter-compatible provider abstraction
• local Ollama-compatible provider support
• embeddings via a configured OpenRouter-compatible embedding model
• local embeddings table

The important data-model choice is to store structured extracted objects separately from raw captures. Markdown can be useful for rendering and export, but Signal Box's power comes from preserving raw input while creating queryable structure beside it.

Core tables:

• captures
• projects
• tasks
• decisions
• questions
• sources
• artefacts
• relationships
• embeddings
• settings

Install dependencies and run the app:

bun install
bun run tauri dev

During desktop development, CommandOrControl+Shift+Space opens the dedicated quick-capture popover. Captures are saved as raw text in SQLite, can remain unassigned, and appear in the unprocessed inbox until archived or later processed.

AI distillation is BYOK. Configure OpenAI, OpenRouter, or a local Ollama-compatible endpoint from Settings, then use the provider test before processing captures. Processing preserves the raw capture and saves extracted title, summary, type, tasks, decisions, open questions, source-like references, and a suggested project beside it.

Projects are the central memory surface. Create projects from the Projects view, attach captures from the inbox, accept matched project suggestions after distillation, then use Project Memory tabs to edit the overview, current direction, tasks, decisions, questions, and sources. Source records can be linked to a project and optionally to a capture so later artefact generation can use the project memory as local context.

The Artefacts view generates the five alpha artefact types from selected project context: product briefs, implementation plans, ADRs, coding-agent prompts, and LinkedIn/blog drafts. Generated markdown can be previewed, copied, saved with provider/model metadata, and linked back to the captures, decisions, tasks, questions, sources, and project memory used to create it.

Search / Ask uses the configured embedding model to index local captures, projects, decisions, tasks, questions, sources, and artefacts into the local embeddings table. The Search screen can run semantic search with keyword fallback, answer grounded questions from retrieved local context, and generate a project recall summary for "Where did I get to?".

Settings includes the alpha demo path, provider setup prompts, keyboard navigation hints, and a local SQLite backup export for local-first confidence.

Build:

bun run tauri build

Generate SQLite migrations after changing the Drizzle schema:

bun run db:generate

Inspect or add shadcn UI components:

bun run ui:info
bun run ui:add button

Signal Box initializes a local SQLite database on desktop app startup. The database is stored in the platform app data directory as signal-box.sqlite3, and the Settings screen exposes the resolved path and latest applied migration for troubleshooting.

The Drizzle schema lives at src/db/schema.ts. Generated SQL migrations live in src-tauri/migrations/ and are applied by the Tauri backend before the frontend checks database health. Capture records preserve raw_text and store assignment, source, type, status, provider processing state, and processing/archive metadata beside it. Project memory keeps editable overview fields on projects, extracted object provenance through capture_id, direct project links on captures/tasks/decisions/questions/sources/artefacts, and relationship rows for reusable context links. Artefacts store their rendered markdown body, summary, provider, model, and metadata JSON locally. Search embeddings store entity type/id, provider, model, dimensions, vector JSON, and content hashes so indexing can skip unchanged local context.

Provider settings are stored locally in SQLite under the settings table. The alpha marks provider settings as secret records and never echoes saved API keys back to the UI, but platform keychain storage is not yet implemented.

Start with:

• docs/scope.md for product scope, positioning, core workflows, and alpha boundaries.
• docs/ui.md for the alpha UI foundation and component guidance.
• docs/plans/00-alpha-roadmap.md for the alpha roadmap and phase order.
• docs/demo.md for the alpha demo script.

Phase plans:

1. Foundation
2. Capture Inbox
3. AI Provider and Distillation
4. Project Memory
5. Artefact Generation
6. Search and Recall
7. Alpha Demo Polish