@a13xu/lucid 1.13.0 → 1.16.1

package/README.md

@@ -4,11 +4,11 @@
 [![npm downloads](https://img.shields.io/npm/dm/@a13xu/lucid)](https://www.npmjs.com/package/@a13xu/lucid)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-> **MCP server for Claude Code** — persistent memory, smart code indexing, and code quality validation. Works out of the box with zero configuration.
+> **MCP server for Claude Code** — persistent memory, smart code indexing, model selection, and code quality validation. Works out of the box with zero configuration.
 
 Token-efficient memory, code indexing, and validation for Claude Code agents — backed by **SQLite + FTS5**.
 
-Stores a persistent knowledge graph (entities, relations, observations), indexes source files as compressed binary with change detection, retrieves minimal relevant context via TF-IDF or Qdrant, and validates code for LLM drift patterns. Supports TypeScript, JavaScript, Python, **Vue, Nuxt**.
+Stores a persistent knowledge graph (entities, relations, observations), indexes source files as compressed binary with change detection, retrieves minimal relevant context via TF-IDF or Qdrant, and validates code for LLM drift patterns. Supports TypeScript, JavaScript, Python, **Vue, Nuxt**. Optional **LLMLingua-2 semantic compression** reduces context tokens by 30–70% while preserving meaning.
 
 ## Install
 
@@ -45,15 +45,16 @@ Default DB path: `~/.claude/memory.db`
 ## Quick start
 
 ```
-1. "Index this project" → init_project()        → scans CLAUDE.md, package.json, src/**
-2. Write code          → sync_file(path)         → compressed + hashed + diff stored
-3. "What's relevant?"  → get_context("auth flow") → TF-IDF ranked skeletons, ~500 tokens
-4. "What changed?"     → get_recent(hours=2)      → line diffs of recent edits
-5. "Where is X used?"  → grep_code("X")           → matching lines only, ~30 tokens
-6. "What do we know?"  → recall("query")          → knowledge graph search
+1. "Index this project" → init_project()               → scans CLAUDE.md, package.json, src/**
+2. Write code           → sync_file(path)               → compressed + hashed + diff stored
+3. "What's relevant?"  → smart_context("auth flow")    → recall + code in one call, adaptive budget
+4. "What model?"       → suggest_model("refactor auth") → haiku (lookup) or sonnet (reasoning)
+5. "What changed?"     → get_recent(hours=2)            → line diffs of recent edits
+6. "Where is X used?"  → grep_code("X")                → matching lines only, ~30 tokens
+7. "What do we know?"  → recall("query")               → knowledge graph search
 ```
 
-## Tools (30)
+## Tools (37)
 
 ### Memory
 | Tool | Description |
@@ -76,8 +77,11 @@ Default DB path: `~/.claude/memory.db`
 ### Token optimization
 | Tool | Description |
 |---|---|
-| `get_context` | **Smart context retrieval.** Ranks all indexed files by TF-IDF relevance (or Qdrant vector search if `QDRANT_URL` is set), applies recency boost, returns skeletons (imports + signatures only) for large files. Respects `maxContextTokens` budget. |
+| `smart_context` | **Recommended entry point.** Combines `recall()` (knowledge graph) + `get_context()` (code files) in one call. Adaptive token budget: `simple`=2000, `moderate`=6000, `complex`=12000. Logs an experience for `reward()`/`penalize()` feedback. |
+| `suggest_model` | Classify task complexity → recommend Claude model. Returns `{ model, model_id, reasoning, context_budget }`. Simple lookups → Haiku; reasoning/code → Sonnet. Call at the start of any workflow. |
+| `get_context` | **Classic code context.** Ranks indexed files by TF-IDF (or Qdrant), applies recency boost, returns skeletons for large files. Respects `maxContextTokens` budget. |
 | `get_recent` | Return files modified in the last N hours with line-level diffs. |
+| `compress_text` | Compress any text using LLMLingua-2 semantic compression. Returns compressed text + stats (ratio, tokens saved). Model downloads ~700MB on first use. |
 
 ### Logic Guardian
 | Tool | Description |
@@ -86,11 +90,19 @@ Default DB path: `~/.claude/memory.db`
 | `check_drift` | Analyze a code snippet inline without saving to disk. |
 | `get_checklist` | Return the full 5-pass validation protocol (Logic Trace, Contract Verification, Stupid Mistakes, Integration Sanity, Explain It). |
 
+### Plans
+| Tool | Description |
+|---|---|
+| `plan_create` | Create a development plan with title, description, and tasks. Returns plan ID. |
+| `plan_list` | List all plans with status summary (total/done/in-progress tasks). |
+| `plan_get` | Get full plan details including all tasks and their status. |
+| `plan_update_task` | Update a task's status (`todo` → `in_progress` → `done`) and optionally add notes. |
+
 ### Reward system
 | Tool | Description |
 |---|---|
-| `reward` | Signal that the last `get_context()` result was helpful (+1). Rewarded files rank higher in future similar queries. |
-| `penalize` | Signal that the last `get_context()` result was unhelpful (-1). Penalized files rank lower in future queries. |
+| `reward` | Signal that the last `smart_context()`/`get_context()` result was helpful (+1). Rewarded files rank higher in future similar queries. |
+| `penalize` | Signal that the last result was unhelpful (-1). Penalized files rank lower. Accepts optional `note` to log what was missing. |
 | `show_rewards` | Show top rewarded experiences and most rewarded files. Rewards decay exponentially (half-life ~14 days). |
 
 ### Code Quality Guard
@@ -115,7 +127,31 @@ Default DB path: `~/.claude/memory.db`
 
 ## Token optimization in depth
 
-### How `get_context` works
+### How `smart_context` works (recommended)
+
+```
+query: "auth middleware"
+         ↓
+  1. recall(query)  — knowledge graph search (entities, relations)
+         ↓
+  2. TF-IDF score all indexed files against query
+     (or Qdrant top-k if QDRANT_URL is set)
+         ↓
+  3. Boost recently-modified files (+0.3 score)
+     Boost rewarded files (+0.25 score, decayed)
+         ↓
+  4. For each file within token budget:
+       file < maxTokensPerFile  → return full source
+       file > maxTokensPerFile  → return skeleton only
+                                   (imports + signatures + TODOs)
+                                   + relevant fragments around query terms
+         ↓
+  5. Optional: LLMLingua-2 compression (if enabled in config)
+         ↓
+  output: merged knowledge + code — budget: 2k/6k/12k by task_type
+```
+
+### How `get_context` works (classic)
 
 ```
 query: "auth middleware"
@@ -183,6 +219,32 @@ Or in `.mcp.json`:
 
 Falls back to TF-IDF automatically if Qdrant is unreachable.
 
+### Semantic compression (optional)
+
+LLMLingua-2 (`microsoft/llmlingua-2-bert-base-multilingual-cased-meetingbank`) identifies and drops semantically unimportant tokens before returning context to Claude — and before generating Qdrant embeddings.
+
+Enable in `lucid.config.json`:
+
+```json
+{
+  "semanticCompression": {
+    "enabled": true,
+    "ratio": 0.5,
+    "minLength": 300,
+    "applyToEmbeddings": true
+  }
+}
+```
+
+| Key | Default | Description |
+|---|---|---|
+| `enabled` | `false` | Opt-in — model downloads ~700MB on first use |
+| `ratio` | `0.5` | Fraction of tokens to keep (0.3 = keep 30%) |
+| `minLength` | `300` | Skip compression for texts shorter than this |
+| `applyToEmbeddings` | `true` | Also compress chunk text before Qdrant embedding |
+
+Model is cached in `~/.lucid/models/` after first download. Falls back to uncompressed text on any error — safe to enable unconditionally.
+
 ### Configuration (`lucid.config.json`)
 
 Create in your project root to customize behavior:
@@ -191,9 +253,13 @@ Create in your project root to customize behavior:
 {
   "whitelistDirs": ["src", "backend", "api"],
   "blacklistDirs": ["migrations", "fixtures"],
-  "maxTokensPerFile": 400,
-  "maxContextTokens": 6000,
-  "recentWindowHours": 12
+  "maxTokensPerFile": 600,
+  "maxContextTokens": 8000,
+  "recentWindowHours": 48,
+  "semanticCompression": {
+    "enabled": false,
+    "ratio": 0.5
+  }
 }
 ```
 
@@ -201,9 +267,9 @@ Create in your project root to customize behavior:
 |---|---|---|
 | `whitelistDirs` | — | Only index/return files from these dirs |
 | `blacklistDirs` | — | Extra dirs to skip (merged with built-in skips) |
-| `maxTokensPerFile` | `400` | Files above this get skeleton treatment |
-| `maxContextTokens` | `4000` | Total token budget for `get_context` |
-| `recentWindowHours` | `24` | "Recently touched" threshold |
+| `maxTokensPerFile` | `600` | Files above this get skeleton treatment |
+| `maxContextTokens` | `8000` | Total token budget for `get_context` |
+| `recentWindowHours` | `48` | "Recently touched" threshold |
 
 ## Why no vectors by default?
 
@@ -237,6 +303,63 @@ TF-IDF is fast, deterministic, and requires zero external services. Qdrant is av
 ## Relation types
 `uses` · `depends_on` · `created_by` · `part_of` · `replaced_by` · `conflicts_with` · `tested_by`
 
+## HTTP daemon & auto-sync
+
+Lucid can run as a background HTTP daemon (port 7821) for auto-syncing files without Claude's cooperation.
+
+```bash
+# Start daemon (watches for sync requests, serves REST API)
+lucid watch
+
+# With HTTP server
+lucid watch --http
+
+# Check status
+lucid status
+
+# Stop
+lucid stop
+```
+
+### REST API (when `--http` is active)
+
+| Endpoint | Description |
+|---|---|
+| `POST /sync` `{ path }` | Sync a single file |
+| `POST /sync-project` `{ directory? }` | Sync entire project |
+| `GET /context?q=<query>` | Get context via HTTP |
+| `POST /validate` `{ path }` | Validate file for drift |
+| `GET /health` | Daemon health check |
+
+### Auto-sync hook (`lucid-sync`)
+
+`init_project` installs a Claude Code `PostToolUse` hook that calls `lucid-sync` after every file write/edit. The sync binary:
+
+1. Tries HTTP sync (500ms timeout, if daemon running)
+2. Falls back to direct SQLite sync (no daemon needed)
+
+This keeps the knowledge graph current automatically — without relying on Claude remembering to call `sync_file`.
+
+## Skills enforcement
+
+Lucid ships **enforcement skills** that install globally into `~/.claude/skills/` and activate in every project:
+
+| Skill | Purpose |
+|---|---|
+| `lucid-start` | Session start — `get_recent` + `smart_context` before any coding |
+| `lucid-context` | Pre-task context loading — `suggest_model` + `smart_context` |
+| `lucid-audit` | Pre-done gate — validate + check drift before marking complete |
+| `lucid-plan` | Planning workflow |
+| `lucid-sync` | Post-edit sync reminder |
+| `lucid-webdev` | Web dev workflow with context |
+
+All skills use `<HARD-GATE>` blocks that prevent proceeding until required tools are called.
+
+Install globally:
+```bash
+init_project()   # installs skills to ~/.claude/skills/ automatically
+```
+
 ## Debugging
 
 ```bash
@@ -244,7 +367,7 @@ echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"capabilities":{},
   | npx @a13xu/lucid
 ```
 
-In Claude Code: run `/mcp` — you should see `lucid` with 20 tools.
+In Claude Code: run `/mcp` — you should see `lucid` with 37 tools.
 
 ## Contributing
 
@@ -260,8 +383,11 @@ Bug reports and pull requests are welcome on [GitHub](https://github.com/a13xu/l
 - **Runtime:** Node.js 18+, TypeScript, ES modules
 - **MCP SDK:** `@modelcontextprotocol/sdk`
 - **Database:** `better-sqlite3` (synchronous, WAL mode)
-- **Compression:** Node.js built-in `zlib` (deflate level 9)
+- **Compression:** Node.js built-in `zlib` (deflate level 9) + LLMLingua-2 semantic compression (optional)
 - **Hashing:** SHA-256 via `crypto` (change detection)
 - **Ranking:** TF-IDF (built-in) or Qdrant (optional, via REST)
+- **Semantic compression:** `@huggingface/transformers` (ONNX Runtime, q8 quantization)
+- **HTTP daemon:** Express 5 on port 7821 (optional)
+- **File watcher:** `chokidar`
 - **Validation:** `zod`
 - **Transport:** stdio

package/build/compression/semantic.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Semantic compression using LLMLingua-2
+ * Model: microsoft/llmlingua-2-bert-base-multilingual-cased-meetingbank
+ *
+ * Reduces text by identifying and dropping semantically unimportant tokens.
+ * Uses @huggingface/transformers (ONNX Runtime) for local inference.
+ *
+ * Pipeline is loaded lazily on first use and cached in memory.
+ * Model files are cached in ~/.lucid/models/ after first download (~700MB).
+ *
+ * Falls back to original text on any error — safe to call unconditionally.
+ */
+export interface SemanticCompressionResult {
+    compressed: string;
+    originalLength: number;
+    compressedLength: number;
+    /** Fraction of tokens kept (1.0 = no compression) */
+    ratio: number;
+    method: "llmlingua2" | "fallback";
+}
+/**
+ * Compress text using LLMLingua-2 token importance scoring.
+ *
+ * @param text         Input text to compress
+ * @param targetRatio  Target compression ratio (0.3 = keep 30%, 0.5 = keep 50%)
+ * @param minLength    Skip compression for texts shorter than this (chars)
+ */
+export declare function compressTextSemantic(text: string, targetRatio?: number, minLength?: number): Promise<SemanticCompressionResult>;
+export declare function tryCompressTextSemantic(text: string, targetRatio?: number, minLength?: number): Promise<string>;
+export declare function isSemanticCompressionAvailable(): Promise<boolean>;
+export declare function warmUpSemanticCompression(): void;

package/build/compression/semantic.js

@@ -0,0 +1,196 @@
+/**
+ * Semantic compression using LLMLingua-2
+ * Model: microsoft/llmlingua-2-bert-base-multilingual-cased-meetingbank
+ *
+ * Reduces text by identifying and dropping semantically unimportant tokens.
+ * Uses @huggingface/transformers (ONNX Runtime) for local inference.
+ *
+ * Pipeline is loaded lazily on first use and cached in memory.
+ * Model files are cached in ~/.lucid/models/ after first download (~700MB).
+ *
+ * Falls back to original text on any error — safe to call unconditionally.
+ */
+import { join } from "path";
+import { homedir } from "os";
+import { mkdirSync } from "fs";
+const MODEL_ID = "microsoft/llmlingua-2-bert-base-multilingual-cased-meetingbank";
+const MODELS_DIR = join(homedir(), ".lucid", "models");
+let _pipeline = null;
+let _loadError = null;
+let _loading = false;
+async function getPipeline() {
+    if (_loadError)
+        throw _loadError;
+    if (_pipeline)
+        return _pipeline;
+    if (_loading) {
+        // Wait for concurrent load
+        await new Promise((resolve) => {
+            const check = setInterval(() => {
+                if (!_loading) {
+                    clearInterval(check);
+                    resolve();
+                }
+            }, 100);
+        });
+        if (_loadError)
+            throw _loadError;
+        if (_pipeline)
+            return _pipeline;
+    }
+    _loading = true;
+    try {
+        mkdirSync(MODELS_DIR, { recursive: true });
+        // Dynamic import keeps startup fast when compression is not used
+        const { pipeline, env } = await import("@huggingface/transformers");
+        env.cacheDir = MODELS_DIR;
+        env.allowRemoteModels = true;
+        process.stderr.write(`[Lucid] Loading LLMLingua-2 model (first run: downloads ~700MB to ${MODELS_DIR})…\n`);
+        _pipeline = (await pipeline("token-classification", MODEL_ID, {
+            dtype: "q8", // 8-bit quantization — smaller, faster, minimal quality loss
+            device: "cpu",
+        }));
+        process.stderr.write("[Lucid] LLMLingua-2 model ready.\n");
+        return _pipeline;
+    }
+    catch (e) {
+        _loadError = e instanceof Error ? e : new Error(String(e));
+        throw _loadError;
+    }
+    finally {
+        _loading = false;
+    }
+}
+// ---------------------------------------------------------------------------
+// Core compression
+// ---------------------------------------------------------------------------
+/**
+ * Compress text using LLMLingua-2 token importance scoring.
+ *
+ * @param text         Input text to compress
+ * @param targetRatio  Target compression ratio (0.3 = keep 30%, 0.5 = keep 50%)
+ * @param minLength    Skip compression for texts shorter than this (chars)
+ */
+export async function compressTextSemantic(text, targetRatio = 0.5, minLength = 300) {
+    if (text.length < minLength) {
+        return {
+            compressed: text,
+            originalLength: text.length,
+            compressedLength: text.length,
+            ratio: 1.0,
+            method: "fallback",
+        };
+    }
+    const pipe = await getPipeline();
+    // Run token classification — each token gets entity "LABEL_0" (drop) / "LABEL_1" (keep)
+    const tokens = await pipe(text, {
+        // Disable aggregation to get per-sub-token results with offsets
+        aggregation_strategy: "none",
+    });
+    if (!tokens || tokens.length === 0) {
+        return {
+            compressed: text,
+            originalLength: text.length,
+            compressedLength: text.length,
+            ratio: 1.0,
+            method: "fallback",
+        };
+    }
+    // Determine importance threshold:
+    // Sort all "keep" scores descending, keep the top (targetRatio * N) tokens
+    const keepScores = tokens
+        .filter((t) => t.entity === "LABEL_1" || t.entity === "1")
+        .map((t) => t.score)
+        .sort((a, b) => b - a);
+    // If not enough LABEL_1 tokens, use score-based threshold
+    let threshold;
+    if (keepScores.length > 0) {
+        const cutoffIdx = Math.floor(tokens.length * targetRatio);
+        // Find the score at the cutoff rank among all tokens sorted by score
+        const allScores = tokens.map((t) => ({
+            score: t.entity === "LABEL_1" || t.entity === "1" ? t.score : 1 - t.score,
+        })).sort((a, b) => b.score - a.score);
+        threshold = allScores[Math.min(cutoffIdx, allScores.length - 1)]?.score ?? 0.5;
+    }
+    else {
+        // Fallback: use raw score threshold
+        threshold = 0.5;
+    }
+    // Mark characters to keep based on token offsets
+    const keepChars = new Uint8Array(text.length);
+    for (const token of tokens) {
+        const isImportant = token.entity === "LABEL_1" ||
+            token.entity === "1" ||
+            (token.entity !== "LABEL_0" && token.entity !== "0" && token.score >= threshold);
+        if (isImportant && token.start !== undefined && token.end !== undefined) {
+            keepChars.fill(1, token.start, token.end);
+        }
+    }
+    // Always keep structural markers (newlines, sentence boundaries)
+    const FORCE_KEEP = new Set(["\n", ".", "!", "?", ","]);
+    for (let i = 0; i < text.length; i++) {
+        if (FORCE_KEEP.has(text[i]))
+            keepChars[i] = 1;
+    }
+    // Reconstruct compressed text from character mask
+    let compressed = "";
+    let prevKept = false;
+    for (let i = 0; i < text.length; i++) {
+        if (keepChars[i]) {
+            // Preserve a single space when skipping tokens in mid-sentence
+            if (!prevKept && compressed.length > 0 && text[i] !== " " && !FORCE_KEEP.has(text[i - 1] ?? "")) {
+                compressed += " ";
+            }
+            compressed += text[i];
+            prevKept = true;
+        }
+        else {
+            prevKept = false;
+        }
+    }
+    // Clean up artefacts from compression
+    compressed = compressed
+        .replace(/  +/g, " ") // multiple spaces → single
+        .replace(/\n{3,}/g, "\n\n") // more than 2 newlines → 2
+        .replace(/ ([.,!?])/g, "$1") // space before punctuation → no space
+        .trim();
+    const keptCount = keepScores.length;
+    const actualRatio = tokens.length > 0 ? keptCount / tokens.length : 1.0;
+    return {
+        compressed,
+        originalLength: text.length,
+        compressedLength: compressed.length,
+        ratio: actualRatio,
+        method: "llmlingua2",
+    };
+}
+// ---------------------------------------------------------------------------
+// Safe wrapper — always returns a string, never throws
+// ---------------------------------------------------------------------------
+export async function tryCompressTextSemantic(text, targetRatio = 0.5, minLength = 300) {
+    try {
+        const result = await compressTextSemantic(text, targetRatio, minLength);
+        return result.compressed;
+    }
+    catch {
+        return text;
+    }
+}
+// ---------------------------------------------------------------------------
+// Availability check — call before bulk compression to fail fast
+// ---------------------------------------------------------------------------
+export async function isSemanticCompressionAvailable() {
+    try {
+        await getPipeline();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ---------------------------------------------------------------------------
+// Warm-up (optional — call at startup to pre-load model)
+// ---------------------------------------------------------------------------
+export function warmUpSemanticCompression() {
+    getPipeline().catch(() => { });
+}

package/build/config.d.ts

@@ -12,6 +12,21 @@ export interface LucidConfig {
     recentWindowHours?: number;
     /** Security guard configuration */
     security?: SecurityConfig;
+    /**
+     * Semantic compression via LLMLingua-2 (microsoft/llmlingua-2-bert-base-multilingual-cased-meetingbank).
+     * When enabled, file content is compressed before being returned to Claude and before Qdrant embedding.
+     * Model is downloaded on first use (~700MB) and cached in ~/.lucid/models/.
+     */
+    semanticCompression?: {
+        /** Enable semantic compression (default: false — opt-in) */
+        enabled?: boolean;
+        /** Target compression ratio: 0.3 = keep 30%, 0.5 = keep 50% (default: 0.5) */
+        ratio?: number;
+        /** Skip compression for texts shorter than this in chars (default: 300) */
+        minLength?: number;
+        /** Also compress text before Qdrant embedding generation (default: true when enabled) */
+        applyToEmbeddings?: boolean;
+    };
     /** Optional Qdrant vector search (falls back to TF-IDF if not configured) */
     qdrant?: {
         url: string;

package/build/http/routes.d.ts

@@ -0,0 +1,3 @@
+import { Router } from "express";
+import type { Statements } from "../database.js";
+export declare function createRoutes(stmts: Statements): Router;

package/build/http/routes.js

@@ -0,0 +1,56 @@
+import { Router } from "express";
+import { handleSyncFile, handleSyncProject } from "../tools/sync.js";
+import { handleGetContext } from "../tools/context.js";
+import { handleValidateFile } from "../tools/guardian.js";
+import { getCurrentVersion } from "../tools/updater.js";
+export function createRoutes(stmts) {
+    const router = Router();
+    // POST /sync — sync a single file
+    router.post("/sync", (req, res) => {
+        try {
+            const result = handleSyncFile(stmts, req.body);
+            res.json({ ok: true, result });
+        }
+        catch (e) {
+            res.status(500).json({ ok: false, error: String(e) });
+        }
+    });
+    // POST /sync-project — sync entire project directory
+    router.post("/sync-project", (req, res) => {
+        try {
+            const result = handleSyncProject(stmts, req.body);
+            res.json({ ok: true, result });
+        }
+        catch (e) {
+            res.status(500).json({ ok: false, error: String(e) });
+        }
+    });
+    // GET /context?q=...&maxTokens=4000 — retrieve relevant context
+    router.get("/context", async (req, res) => {
+        try {
+            const result = await handleGetContext(stmts, {
+                query: String(req.query["q"] ?? ""),
+                maxTokens: req.query["maxTokens"] ? Number(req.query["maxTokens"]) : 4000,
+            });
+            res.json({ ok: true, result });
+        }
+        catch (e) {
+            res.status(500).json({ ok: false, error: String(e) });
+        }
+    });
+    // POST /validate — validate a file for drift/quality issues
+    router.post("/validate", (req, res) => {
+        try {
+            const result = handleValidateFile(req.body);
+            res.json({ ok: true, result });
+        }
+        catch (e) {
+            res.status(500).json({ ok: false, error: String(e) });
+        }
+    });
+    // GET /health — liveness check
+    router.get("/health", (_req, res) => {
+        res.json({ ok: true, version: getCurrentVersion() });
+    });
+    return router;
+}

package/build/http/server.d.ts

@@ -0,0 +1,7 @@
+import type { Server } from "http";
+import type { Statements } from "../database.js";
+export interface HttpServerOptions {
+    port?: number;
+    host?: string;
+}
+export declare function startHttpServer(stmts: Statements, options?: HttpServerOptions): Server;

package/build/http/server.js

@@ -0,0 +1,11 @@
+import express from "express";
+import { createRoutes } from "./routes.js";
+export function startHttpServer(stmts, options = {}) {
+    const { port = 7821, host = "127.0.0.1" } = options;
+    const app = express();
+    app.use(express.json());
+    app.use("/", createRoutes(stmts));
+    return app.listen(port, host, () => {
+        process.stderr.write(`[Lucid] HTTP server listening on ${host}:${port}\n`);
+    });
+}