lific 1.2.1 - Docs.rs

lific-1.2.1 is not a library.

Lific's full MCP schema fits in ~2,500 tokens. It uses human-readable identifiers (APP-42, not UUIDs), runs as a single binary with an embedded SQLite database, and includes a web UI for when you want to look at things yourself.

Install

cargo install lific

Or grab a binary from the releases page.

Quickstart

lific init     # creates lific.toml + lific.db
lific start    # starts on port 3456

On first run, Lific generates an API key and prints it to the console. It won't be shown again. This key is used for MCP and API access.

Open http://localhost:3456 to use the web UI. The first account you create is the admin.

The CLI also works directly against the database. No server or auth required:

lific project list
lific issue list --project APP
lific issue create --project APP --title "Fix login bug" --priority high
lific issue get APP-42
lific issue update APP-42 --status done
lific search "authentication" --project APP

Add --json to any command for machine-readable output.

Connecting AI tools

Point your MCP client at the server. Replace your-api-key with the key from first run (or create one with lific key create --name my-key).

Remote (network):

{
  "lific": {
    "type": "remote",
    "url": "http://localhost:3456/mcp",
    "headers": {
      "Authorization": "Bearer your-api-key"
    }
  }
}

Local (stdio, no network):

{
  "lific": {
    "type": "local",
    "command": ["lific", "--db", "path/to/lific.db", "mcp"]
  }
}

Go to Settings > Connected Tools in the web UI. Pick your tool, click Connect, and paste the generated config snippet. Supported tools: OpenCode, Cursor, Claude Code, Claude Desktop, Codex.

Each connection creates a bot identity tied to your account. Changes show up attributed to you, tagged with which tool made them.

MCP tools

Tool	What it does
`list_issues`	Filter by status, priority, module, label, or workable
`get_issue`	Full issue details with relations, labels, and comments
`create_issue` / `update_issue`	Create or partially update by identifier
`get_board`	Board view grouped by status, priority, or module
`search`	Full-text search across issues and pages
`link_issues` / `unlink_issues`	Dependency tracking (blocks, relates_to, duplicate)
`get_page` / `create_page` / `update_page`	Markdown documents in folders
`add_comment` / `list_comments`	Comments on issues
`list_resources`	Discover projects, modules, labels, folders
`manage_resource`	Create/update projects, modules, labels, folders
`delete`	Delete anything by identifier

Everything uses human-readable identifiers: project="APP" not project_id=7.

Workable filter: list_issues(project="APP", workable=true) returns only issues with all blockers resolved. One call can answer "what can I work on right now?"

Features

Category	What you get
Issue tracking	Status, priority, modules, labels, relations, comments, board view
Documentation	Markdown pages in recursive folders
MCP interface	16 tools, ~2,500 token schema, human-readable identifiers
REST API	Full CRUD for all resources, search, board view
Web UI	Inline editing, drag-and-drop, dark/light theme
User accounts	Individual auth, per-tool bot identities, project lead permissions
OAuth 2.1	PKCE, dynamic client registration, token revocation
Backups	Automatic SQLite snapshots with configurable retention
CLI	Full CRUD for issues, projects, pages, modules, labels, folders. No server needed
Single binary	No runtime dependencies, embedded SQLite, ~15MB

Configuration

lific init generates this:

[server]
host = "0.0.0.0"
port = 3456

[database]
path = "lific.db"

[backup]
enabled = true
dir = "backups"
interval_minutes = 60
retain = 24

[log]
level = "info"

CLI flags (--db, --port, --host) override config values.

Building from source

Requirements

Rust 1.88+ required
Bun optional, only needed if you want the web UI

SQLite is bundled via rusqlite and compiled into the binary. No system SQLite required.

API-only build (no web UI)

git clone https://github.com/VoidNullable/lific
cd lific
mkdir -p web/dist
cargo build --release

The mkdir -p web/dist creates the empty directory that rust-embed expects at compile time. The resulting binary has full functionality (MCP, REST API, CLI, OAuth, backups) but visiting the web UI will return a message pointing you to build the frontend.

Full build (with web UI)

git clone https://github.com/VoidNullable/lific
cd lific
cd web && bun install && bun run build && cd ..
cargo build --release

The frontend is a Svelte 5 SPA built with Vite. bun run build outputs static files to web/dist/, which cargo build embeds into the binary. The final binary is fully self-contained with no runtime dependencies.

Contributing

Issues and PRs welcome. If you're planning something big, open an issue first so we can talk about it before you put in the work.

License

Apache-2.0