@a13xu/lucid 1.12.0 → 1.16.0

package/build/retrieval/context.js

@@ -6,6 +6,7 @@ import { extractSkeleton, renderSkeleton } from "../indexer/ast.js";
 import { searchQdrant } from "./qdrant.js";
 import { getQdrantConfig } from "../config.js";
 import { getFileRewardsMap } from "../memory/experience.js";
+import { tryCompressTextSemantic } from "../compression/semantic.js";
 // ---------------------------------------------------------------------------
 // Token estimation (1 token ≈ 4 chars is the standard heuristic)
 // ---------------------------------------------------------------------------
@@ -183,6 +184,11 @@ export async function assembleContext(query, stmts, cfg, opts = {}) {
         }
         if (isRecent)
             reason += " +recent";
+        // Semantic compression — applied after skeleton/full decision, before token counting
+        if (cfg.semanticCompression?.enabled) {
+            content = await tryCompressTextSemantic(content, cfg.semanticCompression.ratio ?? 0.5, cfg.semanticCompression.minLength ?? 300);
+            reason += " +compressed";
+        }
         const contentTokens = estimateTokens(content);
         if (contentTokens < 10) {
             skippedFiles++;

package/build/retrieval/qdrant.d.ts

@@ -8,7 +8,7 @@ export interface VectorChunk {
     score: number;
 }
 /** Index one file into Qdrant (called by sync_file when Qdrant is configured). */
-export declare function indexFileInQdrant(filepath: string, text: string, cfg: QdrantCfg): Promise<void>;
+export declare function indexFileInQdrant(filepath: string, text: string, cfg: QdrantCfg, compressionCfg?: ResolvedConfig["semanticCompression"]): Promise<void>;
 /** Top-k semantic search across all indexed chunks. */
 export declare function searchQdrant(query: string, topK: number, cfg: QdrantCfg): Promise<VectorChunk[]>;
 /** Check if Qdrant collection exists and is reachable. */

package/build/retrieval/qdrant.js

@@ -2,6 +2,7 @@
 // Only active when QDRANT_URL is set (via env var or lucid.config.json)
 // Falls back silently to TF-IDF when unavailable
 import { safeFetch } from "../security/ssrf.js";
+import { tryCompressTextSemantic } from "../compression/semantic.js";
 // ---------------------------------------------------------------------------
 // Embedding generation (OpenAI-compatible endpoint)
 // ---------------------------------------------------------------------------
@@ -85,16 +86,24 @@ function stableId(s) {
 // Public API
 // ---------------------------------------------------------------------------
 /** Index one file into Qdrant (called by sync_file when Qdrant is configured). */
-export async function indexFileInQdrant(filepath, text, cfg) {
+export async function indexFileInQdrant(filepath, text, cfg, compressionCfg) {
     await ensureCollection(cfg);
     const chunks = chunkFile(filepath, text);
     if (chunks.length === 0)
         return;
+    const compressForEmbedding = compressionCfg?.enabled && compressionCfg.applyToEmbeddings !== false;
     // Batch embed (max 96 texts per request for most providers)
     const BATCH = 32;
     for (let b = 0; b < chunks.length; b += BATCH) {
         const batch = chunks.slice(b, b + BATCH);
-        const vectors = await embed(batch.map((c) => c.text), cfg);
+        let textsToEmbed;
+        if (compressForEmbedding) {
+            textsToEmbed = await Promise.all(batch.map((c) => tryCompressTextSemantic(c.text, compressionCfg.ratio ?? 0.5, compressionCfg.minLength ?? 300)));
+        }
+        else {
+            textsToEmbed = batch.map((c) => c.text);
+        }
+        const vectors = await embed(textsToEmbed, cfg);
         const points = batch.map((c, idx) => ({
             id: c.id,
             vector: vectors[idx],

package/build/tools/compress.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export declare const CompressTextSchema: z.ZodObject<{
+    text: z.ZodString;
+    ratio: z.ZodOptional<z.ZodNumber>;
+    min_length: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    text: string;
+    ratio?: number | undefined;
+    min_length?: number | undefined;
+}, {
+    text: string;
+    ratio?: number | undefined;
+    min_length?: number | undefined;
+}>;
+export declare function handleCompressText(args: z.infer<typeof CompressTextSchema>): Promise<string>;

package/build/tools/compress.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import { compressTextSemantic } from "../compression/semantic.js";
+export const CompressTextSchema = z.object({
+    text: z.string().min(1).describe("Text to compress"),
+    ratio: z.number().min(0.1).max(0.9).optional().describe("Target compression ratio: 0.3 = keep 30%, 0.5 = keep 50% (default: 0.5)"),
+    min_length: z.number().int().optional().describe("Skip compression for texts shorter than this in chars (default: 300)"),
+});
+export async function handleCompressText(args) {
+    const result = await compressTextSemantic(args.text, args.ratio ?? 0.5, args.min_length ?? 300);
+    return JSON.stringify({
+        compressed: result.compressed,
+        original_length: result.originalLength,
+        compressed_length: result.compressedLength,
+        ratio_kept: result.ratio,
+        method: result.method,
+        tokens_saved: Math.ceil((result.originalLength - result.compressedLength) / 4),
+    }, null, 2);
+}

package/build/tools/init.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { resolve, join } from "path";
+import { homedir } from "os";
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "fs";
 import { fileURLToPath } from "url";
 import { indexProject } from "../indexer/project.js";
@@ -29,16 +30,37 @@ export const InitProjectSchema = z.object({
     projectName: z.string().optional(),
 });
 const LUCID_MARKER = "Lucid: call sync_file";
+const LUCID_UPDATE_MARKER = "lucid-update-check";
 const LUCID_HOOK = {
     matcher: "Write|Edit|NotebookEdit",
     hooks: [
         {
             type: "command",
-            command: `echo '🔄 ${LUCID_MARKER}(path) to keep knowledge graph up to date'`,
+            command: `lucid-sync 2>/dev/null || echo '🔄 ${LUCID_MARKER}(path) — install lucid globally: npm i -g @a13xu/lucid'`,
         },
     ],
 };
-function installHook(dir) {
+// SessionStart hook: checks npm registry and notifies if update is available.
+// Uses only Node.js built-in https module — no external dependencies required.
+const LUCID_UPDATE_HOOK = {
+    hooks: [
+        {
+            type: "command",
+            command: `node -e "const h=require('https');` +
+                `h.get('https://registry.npmjs.org/@a13xu/lucid/latest',` +
+                `function(r){var d='';r.on('data',function(c){d+=c});` +
+                `r.on('end',function(){` +
+                `try{var v=JSON.parse(d).version;` +
+                `var s=require('child_process').execSync(` +
+                `'npm list -g @a13xu/lucid --depth=0 2>/dev/null',{encoding:'utf8'});` +
+                `var m=s.match(/lucid@([\\d.]+)/);` +
+                `if(m&&m[1]&&v!==m[1])` +
+                `console.log('[Lucid] Update available: v'+m[1]+' → v'+v+'. Call update_lucid().')}` +
+                `catch(e){}})}).on('error',function(){})" 2>/dev/null || true`,
+        },
+    ],
+};
+function installHooks(dir) {
     const claudeDir = join(dir, ".claude");
     const settingsPath = join(claudeDir, "settings.json");
     let settings = {};
@@ -51,20 +73,34 @@ function installHook(dir) {
         }
     }
     const hooks = (settings["hooks"] ?? {});
+    let changed = false;
+    // ── PostToolUse: sync_file reminder ──────────────────────────────────────
     const postToolUse = hooks["PostToolUse"] ?? [];
-    // Detectează atât formatul vechi cât și cel nou
-    const alreadyInstalled = postToolUse.some((h) => {
+    const syncAlreadyInstalled = postToolUse.some((h) => {
         const cmd = h.command ?? h.hooks?.[0]?.command ?? "";
         return cmd.includes(LUCID_MARKER);
     });
-    if (alreadyInstalled) {
+    if (!syncAlreadyInstalled) {
+        hooks["PostToolUse"] = [...postToolUse, LUCID_HOOK];
+        changed = true;
+    }
+    // ── SessionStart: version check ───────────────────────────────────────────
+    const sessionStart = hooks["SessionStart"] ?? [];
+    const updateAlreadyInstalled = sessionStart.some((h) => {
+        const cmd = h.command ?? h.hooks?.[0]?.command ?? "";
+        return cmd.includes(LUCID_UPDATE_MARKER);
+    });
+    if (!updateAlreadyInstalled) {
+        hooks["SessionStart"] = [...sessionStart, LUCID_UPDATE_HOOK];
+        changed = true;
+    }
+    if (!changed) {
         return { installed: false, reason: "already installed" };
     }
-    hooks["PostToolUse"] = [...postToolUse, LUCID_HOOK];
     settings["hooks"] = hooks;
     mkdirSync(claudeDir, { recursive: true });
     writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
-    return { installed: true, reason: "hook added to .claude/settings.json" };
+    return { installed: true, reason: "hooks added to .claude/settings.json" };
 }
 // ---------------------------------------------------------------------------
 // Adaugă instrucțiune în CLAUDE.md
@@ -111,13 +147,14 @@ export async function handleInitProject(stmts, input) {
     }
     // ── Hook PostToolUse ──────────────────────────────────────────────────────
     lines.push(``);
-    const hookResult = installHook(dir);
+    const hookResult = installHooks(dir);
     if (hookResult.installed) {
-        lines.push(`🔗 Claude Code hook installed (.claude/settings.json)`);
-        lines.push(`   After every Write/Edit, you will see a reminder to call sync_file().`);
+        lines.push(`🔗 Claude Code hooks installed (.claude/settings.json)`);
+        lines.push(`   PostToolUse: reminder to call sync_file() after every Write/Edit`);
+        lines.push(`   SessionStart: auto-check for Lucid updates on session start`);
     }
     else {
-        lines.push(`🔗 Hook: ${hookResult.reason}`);
+        lines.push(`🔗 Hooks: ${hookResult.reason}`);
     }
     // ── Skills ────────────────────────────────────────────────────────────────
     const skillsResult = installSkills(dir);
@@ -131,6 +168,17 @@ export async function handleInitProject(stmts, input) {
     else if (skillsResult.skipped.length > 0) {
         lines.push(`📚 Skills: already installed (${skillsResult.skipped.length} skill(s))`);
     }
+    // ── Global skills (~/.claude/skills/) ────────────────────────────────────
+    const globalSkillsResult = installGlobalSkills();
+    if (globalSkillsResult.installed.length > 0) {
+        lines.push(`🌐 Global skills installed in ~/.claude/skills/:`);
+        for (const s of globalSkillsResult.installed) {
+            lines.push(`   • /${s} (available in all projects)`);
+        }
+    }
+    else if (globalSkillsResult.skipped.length > 0) {
+        lines.push(`🌐 Global skills: already installed (${globalSkillsResult.skipped.length} skill(s))`);
+    }
     // ── CLAUDE.md injection ───────────────────────────────────────────────────
     const injected = injectClaudeMdInstruction(dir);
     if (injected) {
@@ -241,6 +289,9 @@ function installSkills(projectDir) {
     }
     return result;
 }
+function installGlobalSkills() {
+    return installSkills(homedir());
+}
 function buildChannelSummary(cfg) {
     const channels = [];
     if (cfg.adminEmail && cfg.smtpHost)

package/build/tools/model-advisor.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export declare const SuggestModelSchema: z.ZodObject<{
+    task_description: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    task_description: string;
+}, {
+    task_description: string;
+}>;
+export declare function handleSuggestModel(args: z.infer<typeof SuggestModelSchema>): string;

package/build/tools/model-advisor.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+export const SuggestModelSchema = z.object({
+    task_description: z.string().min(1).describe("Natural language description of the task you are about to perform"),
+});
+const HAIKU_TRIGGERS = [
+    "list", "show", "find", "search", "where", "what is",
+    "recall", "get recent", "status",
+];
+const MODEL_IDS = {
+    haiku: "claude-haiku-4-5-20251001",
+    sonnet: "claude-sonnet-4-6",
+};
+const CONTEXT_BUDGETS = {
+    haiku: 2000,
+    sonnet: 8000,
+};
+export function handleSuggestModel(args) {
+    const lower = args.task_description.toLowerCase();
+    const haikuTrigger = HAIKU_TRIGGERS.find((t) => lower.includes(t));
+    const model = haikuTrigger ? "haiku" : "sonnet";
+    const reasoning = haikuTrigger
+        ? `Task matches retrieval/lookup pattern ("${haikuTrigger}") — Haiku is faster for read-only queries.`
+        : "No simple retrieval trigger detected — defaulting to Sonnet for reasoning, code generation, and analysis.";
+    return JSON.stringify({
+        model,
+        model_id: MODEL_IDS[model],
+        reasoning,
+        context_budget: CONTEXT_BUDGETS[model],
+    }, null, 2);
+}

package/build/tools/smart-context.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import type { Statements } from "../database.js";
+export declare const SmartContextSchema: z.ZodObject<{
+    query: z.ZodString;
+    task_type: z.ZodOptional<z.ZodEnum<["simple", "moderate", "complex"]>>;
+    dirs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+    dirs?: string[] | undefined;
+    task_type?: "simple" | "moderate" | "complex" | undefined;
+}, {
+    query: string;
+    dirs?: string[] | undefined;
+    task_type?: "simple" | "moderate" | "complex" | undefined;
+}>;
+export declare function handleSmartContext(stmts: Statements, args: z.infer<typeof SmartContextSchema>): Promise<string>;

package/build/tools/smart-context.js

@@ -0,0 +1,54 @@
+import { z } from "zod";
+import { assembleContext } from "../retrieval/context.js";
+import { recall } from "./recall.js";
+import { loadConfig } from "../config.js";
+import { createExperience } from "../memory/experience.js";
+export const SmartContextSchema = z.object({
+    query: z.string().min(1).describe("What you are working on — used for both code retrieval and knowledge graph search"),
+    task_type: z.enum(["simple", "moderate", "complex"]).optional().describe("Token budget: simple=2000, moderate=6000 (default), complex=12000"),
+    dirs: z.array(z.string()).optional().describe("Whitelist: only return files from these directories"),
+});
+const TASK_BUDGETS = {
+    simple: 2000,
+    moderate: 6000,
+    complex: 12000,
+};
+export async function handleSmartContext(stmts, args) {
+    const cfg = loadConfig();
+    const maxTokens = TASK_BUDGETS[args.task_type ?? "moderate"] ?? 6000;
+    // 1. Knowledge graph entities (synchronous)
+    const recallResult = recall(stmts, { query: args.query });
+    // 2. Code context with adaptive budget (async)
+    const contextResult = await assembleContext(args.query, stmts, cfg, {
+        maxTokens,
+        dirs: args.dirs,
+    });
+    // 3. Log experience so reward()/penalize() work after this call
+    const expId = createExperience(args.query, contextResult.files.map((f) => f.filepath), contextResult.strategy, stmts);
+    const budgetUsedPct = Math.round((contextResult.totalTokens / maxTokens) * 100);
+    const sections = [
+        "## Knowledge Context (entities)",
+        recallResult,
+        "",
+        "## Code Context (files)",
+    ];
+    if (contextResult.files.length === 0) {
+        sections.push("No relevant files found. Run init_project() or sync_project() first.");
+    }
+    else {
+        for (const f of contextResult.files) {
+            sections.push(`// ─── ${f.filepath} [${f.language}] ~${f.tokens}t (${f.reason}) ───`);
+            sections.push(f.content);
+            sections.push("");
+        }
+        if (contextResult.truncated) {
+            sections.push(`// ⚠️  Truncated — ${contextResult.skippedFiles} files skipped. Use task_type="complex" for more.`);
+        }
+    }
+    sections.push("", "---");
+    sections.push(`Strategy: ${contextResult.strategy}`);
+    sections.push(`Files: ${contextResult.files.length} files, ${contextResult.totalTokens} tokens`);
+    sections.push(`Budget used: ${budgetUsedPct}%`);
+    sections.push(`Experience #${expId} logged. Call reward() if helpful, penalize() if not.`);
+    return sections.join("\n");
+}

package/build/tools/sync.js

@@ -6,6 +6,8 @@ import { indexProject } from "../indexer/project.js";
 import { computeDiff } from "../retrieval/context.js";
 import { decompress } from "../store/content.js";
 import { implicitRewardFromSync } from "../memory/experience.js";
+import { indexFileInQdrant } from "../retrieval/qdrant.js";
+import { loadConfig, getQdrantConfig } from "../config.js";
 const SUPPORTED_EXTS = new Set([".ts", ".tsx", ".js", ".jsx", ".vue", ".py", ".go", ".rs"]);
 // ---------------------------------------------------------------------------
 // sync_file
@@ -51,6 +53,12 @@ export function handleSyncFile(stmts, args) {
     const implicitRewarded = implicitRewardFromSync(filepath, stmts);
     if (implicitRewarded)
         lines.push(`   🎯 Implicit reward +0.3 (file was in recent context)`);
+    // Qdrant vector indexing — fire-and-forget (Qdrant is optional, silent on failure)
+    const cfg = loadConfig();
+    const qdrantCfg = getQdrantConfig(cfg);
+    if (qdrantCfg) {
+        void indexFileInQdrant(filepath, source, qdrantCfg, cfg.semanticCompression).catch(() => { });
+    }
     return lines.join("\n");
 }
 // ---------------------------------------------------------------------------

package/build/tools/updater.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+export declare function getCurrentVersion(): string;
+export declare function checkForUpdatesOnStartup(): Promise<void>;
+export declare const UpdateLucidSchema: z.ZodObject<{
+    force: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    force?: boolean | undefined;
+}, {
+    force?: boolean | undefined;
+}>;
+export declare function handleUpdateLucid(args: z.infer<typeof UpdateLucidSchema>): Promise<string>;

package/build/tools/updater.js

@@ -0,0 +1,133 @@
+import { z } from "zod";
+import { join } from "path";
+import { readFileSync, existsSync } from "fs";
+import { fileURLToPath } from "url";
+import { execSync } from "child_process";
+// ---------------------------------------------------------------------------
+// Package root resolution
+// ---------------------------------------------------------------------------
+// build/tools/updater.js → ../../ = package root
+const PACKAGE_ROOT = join(fileURLToPath(new URL(".", import.meta.url)), "../..");
+export function getCurrentVersion() {
+    try {
+        const pkg = JSON.parse(readFileSync(join(PACKAGE_ROOT, "package.json"), "utf-8"));
+        return pkg.version ?? "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
+// ---------------------------------------------------------------------------
+// npm registry check
+// ---------------------------------------------------------------------------
+async function fetchLatestVersion() {
+    try {
+        const res = await fetch("https://registry.npmjs.org/@a13xu/lucid/latest", { signal: AbortSignal.timeout(5000) });
+        if (!res.ok)
+            return null;
+        const data = (await res.json());
+        return data.version ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function compareVersions(a, b) {
+    const pa = a.split(".").map(Number);
+    const pb = b.split(".").map(Number);
+    for (let i = 0; i < 3; i++) {
+        const diff = (pa[i] ?? 0) - (pb[i] ?? 0);
+        if (diff !== 0)
+            return diff;
+    }
+    return 0;
+}
+// ---------------------------------------------------------------------------
+// Install method detection
+// ---------------------------------------------------------------------------
+function detectInstallMethod() {
+    // If the package root is inside node_modules, it's npm-installed
+    if (PACKAGE_ROOT.includes("node_modules")) {
+        return "global-npm";
+    }
+    // Check if there's a .git folder — local source checkout
+    if (existsSync(join(PACKAGE_ROOT, ".git"))) {
+        return "local-source";
+    }
+    return "global-npm";
+}
+// ---------------------------------------------------------------------------
+// Startup check (non-blocking — call from index.ts without await)
+// ---------------------------------------------------------------------------
+export async function checkForUpdatesOnStartup() {
+    const current = getCurrentVersion();
+    const latest = await fetchLatestVersion();
+    if (latest && compareVersions(latest, current) > 0) {
+        console.error(`[lucid] ⬆️  Update available: v${current} → v${latest}. ` +
+            `Call update_lucid() to update, or: npm install -g @a13xu/lucid@latest`);
+    }
+}
+// ---------------------------------------------------------------------------
+// Schema & handler
+// ---------------------------------------------------------------------------
+export const UpdateLucidSchema = z.object({
+    force: z
+        .boolean()
+        .optional()
+        .describe("Force reinstall even if already on latest version"),
+});
+// Example call:
+//   handleUpdateLucid({ force: false })
+export async function handleUpdateLucid(args) {
+    const current = getCurrentVersion();
+    const lines = [`🔍 Checking for updates... (current: v${current})`];
+    const latest = await fetchLatestVersion();
+    if (!latest) {
+        return lines.concat("❌ Could not reach npm registry. Check your internet connection.").join("\n");
+    }
+    lines.push(`📦 Latest on npm: v${latest}`);
+    const upToDate = compareVersions(latest, current) <= 0;
+    if (upToDate && !args.force) {
+        lines.push(`✅ Lucid is up to date.`);
+        return lines.join("\n");
+    }
+    if (upToDate && args.force) {
+        lines.push(`⚠️  Already on v${latest}, reinstalling (force=true)...`);
+    }
+    else {
+        lines.push(`🔄 Updating v${current} → v${latest}...`);
+    }
+    const method = detectInstallMethod();
+    if (method === "local-source") {
+        lines.push(``);
+        lines.push(`📁 Local source installation detected (${PACKAGE_ROOT}).`);
+        lines.push(`Run these commands to update:`);
+        lines.push(`  cd "${PACKAGE_ROOT}"`);
+        lines.push(`  git pull`);
+        lines.push(`  npm run build`);
+        lines.push(`Then restart Claude Code.`);
+        return lines.join("\n");
+    }
+    // Global npm install
+    try {
+        lines.push(`Running: npm install -g @a13xu/lucid@${latest}`);
+        execSync(`npm install -g @a13xu/lucid@${latest}`, {
+            timeout: 120_000,
+            stdio: "pipe",
+        });
+        lines.push(`✅ Updated to v${latest}`);
+        lines.push(``);
+        lines.push(`⚠️  Restart Claude Code to load the new version:`);
+        lines.push(`   • VS Code: Cmd/Ctrl+Shift+P → "Restart Claude Code"`);
+        lines.push(`   • CLI: exit and re-run \`claude\``);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        lines.push(`❌ Auto-update failed: ${msg}`);
+        lines.push(`   Run manually: npm install -g @a13xu/lucid@${latest}`);
+        if (process.platform !== "win32") {
+            lines.push(`   Or with sudo: sudo npm install -g @a13xu/lucid@${latest}`);
+        }
+    }
+    return lines.join("\n");
+}

package/package.json

@@ -1,59 +1,64 @@
-{
-  "name": "@a13xu/lucid",
-  "version": "1.12.0",
-  "description": "Token-efficient memory, code indexing, and validation for Claude Code agents — SQLite + FTS5, TF-IDF + Qdrant retrieval, AST skeleton pruning, diff-aware context, Logic Guardian drift detection",
-  "type": "module",
-  "bin": {
-    "lucid": "./build/index.js"
-  },
-  "files": [
-    "build/**/*.js",
-    "build/**/*.d.ts",
-    "skills/**/*.md",
-    "README.md"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "prepublishOnly": "npm run build"
-  },
-  "keywords": [
-    "mcp",
-    "claude",
-    "claude-code",
-    "memory",
-    "sqlite",
-    "knowledge-graph",
-    "code-indexing",
-    "logic-guardian",
-    "drift-detection",
-    "tfidf",
-    "qdrant",
-    "token-optimization",
-    "context-pruning",
-    "ai",
-    "anthropic"
-  ],
-  "author": "a13xu",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/a13xu/lucid.git"
-  },
-  "homepage": "https://github.com/a13xu/lucid#readme",
-  "publishConfig": {
-    "access": "public"
-  },
-  "engines": {
-    "node": ">=18"
-  },
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0",
-    "better-sqlite3": "^12.0.0",
-    "zod": "^3.23.8"
-  },
-  "devDependencies": {
-    "@types/better-sqlite3": "^7.6.11",
-    "@types/node": "^22.0.0",
-    "typescript": "^5.4.0"
-  }
-}
+{
+  "name": "@a13xu/lucid",
+  "version": "1.16.0",
+  "description": "Token-efficient memory, code indexing, and validation for Claude Code agents — SQLite + FTS5, TF-IDF + Qdrant retrieval, AST skeleton pruning, diff-aware context, Logic Guardian drift detection",
+  "type": "module",
+  "bin": {
+    "lucid": "./build/index.js",
+    "lucid-sync": "./build/lucid-sync.js"
+  },
+  "files": [
+    "build/**/*.js",
+    "build/**/*.d.ts",
+    "skills/**/*.md",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "claude",
+    "claude-code",
+    "memory",
+    "sqlite",
+    "knowledge-graph",
+    "code-indexing",
+    "logic-guardian",
+    "drift-detection",
+    "tfidf",
+    "qdrant",
+    "token-optimization",
+    "context-pruning",
+    "ai",
+    "anthropic"
+  ],
+  "author": "a13xu",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/a13xu/lucid.git"
+  },
+  "homepage": "https://github.com/a13xu/lucid#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@huggingface/transformers": "^4.0.0",
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "better-sqlite3": "^12.0.0",
+    "chokidar": "^4.0.3",
+    "express": "^5.2.1",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.11",
+    "@types/express": "^5.0.6",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.4.0"
+  }
+}