@a13xu/lucid 1.9.2 → 1.9.5

package/README.md

@@ -1,8 +1,14 @@
 # @a13xu/lucid
 
+[![npm version](https://img.shields.io/npm/v/@a13xu/lucid)](https://www.npmjs.com/package/@a13xu/lucid)
+[![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.
+
 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.
+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**.
 
 ## Install
 
@@ -226,6 +232,15 @@ echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"capabilities":{},
 
 In Claude Code: run `/mcp` — you should see `lucid` with 20 tools.
 
+## Contributing
+
+Bug reports and pull requests are welcome on [GitHub](https://github.com/a13xu/lucid).
+
+1. Fork the repo
+2. `npm install` → `npm run build`
+3. Test locally: `claude mcp add --transport stdio lucid-dev -- node /path/to/lucid/build/index.js`
+4. Open a PR
+
 ## Tech stack
 
 - **Runtime:** Node.js 18+, TypeScript, ES modules

package/build/index.js

@@ -52,7 +52,7 @@ else {
 // ---------------------------------------------------------------------------
 // MCP Server
 // ---------------------------------------------------------------------------
-const server = new Server({ name: "lucid", version: "1.9.2" }, { capabilities: { tools: {} } });
+const server = new Server({ name: "lucid", version: "1.9.5" }, { capabilities: { tools: {} } });
 // ---------------------------------------------------------------------------
 // Tool definitions
 // ---------------------------------------------------------------------------
@@ -178,7 +178,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 type: "object",
                 properties: {
                     pattern: { type: "string", description: "Regex pattern to search for." },
-                    language: { type: "string", enum: ["python", "javascript", "typescript", "generic"], description: "Filter by language." },
+                    language: { type: "string", enum: ["python", "javascript", "typescript", "vue", "generic"], description: "Filter by language." },
                     context: { type: "number", description: "Lines of context before/after each match (0-10, default 2)." },
                 },
                 required: ["pattern"],

package/build/indexer/ast.js

@@ -108,6 +108,32 @@ function skeletonPython(source) {
     return { imports, exports, todos, summary };
 }
 // ---------------------------------------------------------------------------
+// Vue SFC
+// ---------------------------------------------------------------------------
+function skeletonVue(source) {
+    // Extract <script> or <script setup> block and run TS skeleton on it
+    const scriptMatch = source.match(/<script[^>]*>([\s\S]*?)<\/script>/);
+    const sk = scriptMatch ? skeletonTS(scriptMatch[1]) : { imports: [], exports: [], todos: [], summary: "" };
+    // Prepend Vue macro signatures (defineProps, defineEmits, defineExpose)
+    const scriptContent = scriptMatch?.[1] ?? "";
+    for (const macro of ["defineProps", "defineEmits", "defineExpose"]) {
+        const m = scriptContent.match(new RegExp(`${macro}[\\s\\S]*?(?=\\n\\n|\\n[^\\s]|$)`, "m"));
+        if (m)
+            sk.exports.unshift(m[0].split("\n")[0].slice(0, 120));
+    }
+    // HTML comment as summary fallback
+    if (!sk.summary) {
+        const htmlComment = source.match(/<!--\s*([\s\S]*?)\s*-->/)?.[1];
+        if (htmlComment)
+            sk.summary = htmlComment.replace(/\n/g, " ").trim().slice(0, 150);
+    }
+    // Also note top-level template structure (first tag inside <template>)
+    const templateMatch = source.match(/<template[^>]*>\s*<(\w[\w-]*)/);
+    if (templateMatch)
+        sk.exports.unshift(`<template> root: <${templateMatch[1]}>`);
+    return sk;
+}
+// ---------------------------------------------------------------------------
 // Generic (markdown, yaml, json, etc.)
 // ---------------------------------------------------------------------------
 function skeletonGeneric(source) {
@@ -135,6 +161,8 @@ export function extractSkeleton(source, language) {
             return skeletonTS(source);
         case "python":
             return skeletonPython(source);
+        case "vue":
+            return skeletonVue(source);
         default:
             return skeletonGeneric(source);
     }

package/build/indexer/file.d.ts

@@ -6,6 +6,8 @@ export interface FileIndex {
     todos: string[];
     language: string;
 }
+/** Build a FileIndex from already-read source — no IO. */
+export declare function buildFileIndex(filepath: string, source: string): FileIndex;
 export declare function indexFile(filepath: string): FileIndex | null;
 export interface UpsertResult {
     observations: string[];

package/build/indexer/file.js

@@ -36,6 +36,36 @@ function extractPython(source) {
     }
     return { exports, description, todos };
 }
+function extractVue(source) {
+    const exports = [];
+    const todos = [];
+    // Extract <script> or <script setup> block
+    const scriptMatch = source.match(/<script[^>]*>([\s\S]*?)<\/script>/);
+    const scriptContent = scriptMatch?.[1] ?? "";
+    // defineExpose({ foo, bar }) — symbols available to parent components
+    const exposeMatch = scriptContent.match(/defineExpose\(\s*\{([^}]+)\}/);
+    if (exposeMatch) {
+        for (const m of exposeMatch[1].matchAll(/\b([a-zA-Z_]\w*)\b/g)) {
+            if (!["true", "false", "null", "undefined"].includes(m[1])) {
+                exports.push(m[1]);
+            }
+        }
+    }
+    // Regular named exports inside <script> (non-setup composables, types, etc.)
+    for (const m of scriptContent.matchAll(/export\s+(?:async\s+)?(?:function|class|const|type|interface|enum)\s+(\w+)/g)) {
+        exports.push(m[1]);
+    }
+    // TODOs from entire SFC (template + script + style)
+    for (const m of source.matchAll(/\/\/\s*(TODO|FIXME|HACK)[:\s]+(.+)/gi)) {
+        todos.push(`${m[1]}: ${m[2].trim()}`);
+    }
+    // Description: first HTML comment, then first JSDoc in script
+    const htmlComment = source.match(/<!--\s*([\s\S]*?)\s*-->/)?.[1] ?? "";
+    const jsdoc = scriptContent.match(/^\/\*\*([\s\S]*?)\*\//m)?.[1] ?? "";
+    const raw = htmlComment || jsdoc;
+    const description = raw.replace(/\s*\*\s*/g, " ").trim().slice(0, 200);
+    return { exports, description, todos };
+}
 function extractGeneric(source) {
     const todos = [];
     for (const m of source.matchAll(/(?:\/\/|#)\s*(TODO|FIXME|HACK)[:\s]+(.+)/gi)) {
@@ -43,14 +73,8 @@ function extractGeneric(source) {
     }
     return { exports: [], description: "", todos };
 }
-export function indexFile(filepath) {
-    let source;
-    try {
-        source = readFileSync(filepath, { encoding: "utf-8" });
-    }
-    catch {
-        return null;
-    }
+/** Build a FileIndex from already-read source — no IO. */
+export function buildFileIndex(filepath, source) {
     const ext = extname(filepath).toLowerCase();
     const module = filepath.replace(/\\/g, "/");
     let extracted;
@@ -63,12 +87,26 @@ export function indexFile(filepath) {
         extracted = extractPython(source);
         language = "python";
     }
+    else if (ext === ".vue") {
+        extracted = extractVue(source);
+        language = "vue";
+    }
     else {
         extracted = extractGeneric(source);
         language = "generic";
     }
     return { module, language, ...extracted };
 }
+export function indexFile(filepath) {
+    let source;
+    try {
+        source = readFileSync(filepath, { encoding: "utf-8" });
+    }
+    catch {
+        return null;
+    }
+    return buildFileIndex(filepath, source);
+}
 export function upsertFileIndex(index, source, stmts) {
     const fileHash = sha256(source);
     // Change detection — skip everything se hash-ul e identic

package/build/indexer/project.js

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync, readdirSync, statSync } from "fs";
 import { join, extname, basename } from "path";
+import { buildFileIndex, upsertFileIndex } from "./file.js";
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -181,40 +182,74 @@ function indexLogicGuardianYaml(path, stmts, results) {
         results.push({ entity: `${patternMatches.length} drift patterns`, type: "pattern", observations: patternMatches.length, source: "logic-guardian.yaml" });
     }
 }
+function indexNuxtConfig(path, projectName, stmts, results) {
+    const content = readFile(path);
+    if (!content)
+        return;
+    const obs = [`nuxt config: ${basename(path)}`];
+    // Modules list: modules: ['@nuxtjs/...', ...]
+    const modulesMatch = content.match(/modules\s*:\s*\[([^\]]+)\]/);
+    if (modulesMatch) {
+        const modules = [...modulesMatch[1].matchAll(/['"`](@?[\w/@-]+)['"`]/g)].map((m) => m[1]);
+        if (modules.length > 0)
+            obs.push(`nuxt modules: ${modules.join(", ")}`);
+    }
+    // extends (Nuxt layers)
+    const extendsMatch = content.match(/extends\s*:\s*\[?['"`]([^'"`]+)['"`]/);
+    if (extendsMatch)
+        obs.push(`extends layer: ${extendsMatch[1]}`);
+    // ssr setting
+    const ssrMatch = content.match(/ssr\s*:\s*(true|false)/);
+    if (ssrMatch)
+        obs.push(`ssr: ${ssrMatch[1]}`);
+    // runtimeConfig public keys
+    const rtMatch = content.match(/runtimeConfig\s*:\s*\{([\s\S]*?)(?=\n\s{0,4}\w|\n\})/);
+    if (rtMatch) {
+        const keys = [...rtMatch[1].matchAll(/^\s{2,}(\w+)\s*:/gm)].map((m) => m[1]);
+        if (keys.length > 0)
+            obs.push(`runtimeConfig keys: ${keys.slice(0, 10).join(", ")}`);
+    }
+    upsert(stmts, projectName, "project", obs);
+    results.push({ entity: projectName, type: "project", observations: obs.length, source: basename(path) });
+}
 // Source file indexing — extrage exporturi, clase, funcții principale
-const SOURCE_EXTS = new Set([".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".rs"]);
-const SKIP_DIRS = new Set(["node_modules", ".git", "build", "dist", "__pycache__", ".next", "venv", ".venv", "target", ".cache", "coverage", ".nyc_output"]);
+const SOURCE_EXTS = new Set([".ts", ".tsx", ".js", ".jsx", ".vue", ".py", ".go", ".rs"]);
+const SKIP_DIRS = new Set([
+    "node_modules", ".git",
+    // Generic build output
+    "build", "dist",
+    // Python
+    "__pycache__", "venv", ".venv",
+    // Rust
+    "target",
+    // Next.js
+    ".next",
+    // Nuxt
+    ".nuxt", ".output",
+    // General
+    ".cache", "coverage", ".nyc_output",
+]);
 const MAX_SOURCE_FILES = 10_000;
 function indexSourceFile(filepath, rootDir, projectName, stmts) {
     const content = readFile(filepath);
     if (!content)
-        return [];
-    const exports = [];
-    const lang = extname(filepath);
-    // TypeScript / JavaScript
-    if ([".ts", ".tsx", ".js", ".jsx"].includes(lang)) {
-        for (const m of content.matchAll(/export\s+(?:async\s+)?(?:function|class|const|type|interface)\s+(\w+)/g)) {
-            exports.push(m[1]);
-        }
-    }
-    // Python
-    if (lang === ".py") {
-        for (const m of content.matchAll(/^(?:def|class|async def)\s+(\w+)/gm)) {
-            if (!m[1].startsWith("_"))
-                exports.push(m[1]);
-        }
+        return { exports: [], stored: false };
+    // Build structured index (language-aware, single read)
+    const fileIdx = buildFileIndex(filepath, content);
+    // Store compressed content in source file index → enables get_context() + grep_code()
+    const result = upsertFileIndex(fileIdx, content, stmts);
+    // Add exports to knowledge graph (for recall())
+    if (fileIdx.exports.length > 0) {
+        const relPath = filepath.replace(/\\/g, "/").replace(rootDir.replace(/\\/g, "/") + "/", "");
+        const obs = [`exports from ${relPath}: ${fileIdx.exports.slice(0, 10).join(", ")}`];
+        upsert(stmts, projectName, "project", obs);
     }
-    if (exports.length === 0)
-        return [];
-    // Cale relativă față de rădăcina proiectului
-    const relPath = filepath.replace(/\\/g, "/").replace(rootDir.replace(/\\/g, "/") + "/", "");
-    const obs = [`exports from ${relPath}: ${exports.slice(0, 10).join(", ")}`];
-    upsert(stmts, projectName, "project", obs);
-    return exports;
+    return { exports: fileIdx.exports, stored: result.stored };
 }
 function scanSources(dir, projectName, stmts, results) {
     const rootDir = dir.replace(/\\/g, "/");
     let fileCount = 0;
+    let storedCount = 0;
     const exportedSymbols = [];
     function walk(d) {
         if (fileCount >= MAX_SOURCE_FILES)
@@ -241,9 +276,11 @@ function scanSources(dir, projectName, stmts, results) {
                 walk(full);
             }
             else if (SOURCE_EXTS.has(extname(entry).toLowerCase())) {
-                const syms = indexSourceFile(full, rootDir, projectName, stmts);
+                const { exports: syms, stored } = indexSourceFile(full, rootDir, projectName, stmts);
                 exportedSymbols.push(...syms);
                 fileCount++;
+                if (stored)
+                    storedCount++;
                 if (fileCount >= MAX_SOURCE_FILES)
                     return;
             }
@@ -255,7 +292,7 @@ function scanSources(dir, projectName, stmts, results) {
             entity: projectName,
             type: "project",
             observations: fileCount,
-            source: `${fileCount} source files (${exportedSymbols.length} exports)`,
+            source: `${fileCount} source files (${storedCount} compressed, ${exportedSymbols.length} exports)`,
         });
     }
 }
@@ -314,7 +351,22 @@ export function indexProject(directory, stmts) {
     if (existsSync(join(dir, "logic-guardian.yaml"))) {
         indexLogicGuardianYaml(join(dir, "logic-guardian.yaml"), stmts, results);
     }
-    // 7. Surse
+    // 7. Nuxt config files (nuxt.config.ts/.js, app.config.ts)
+    for (const p of ["nuxt.config.ts", "nuxt.config.js", "nuxt.config.mts"]) {
+        const full = join(dir, p);
+        if (existsSync(full)) {
+            indexNuxtConfig(full, projectName, stmts, results);
+            break;
+        }
+    }
+    for (const p of ["app.config.ts", "app.config.js"]) {
+        const full = join(dir, p);
+        if (existsSync(full)) {
+            indexNuxtConfig(full, projectName, stmts, results);
+            break;
+        }
+    }
+    // 8. Surse
     scanSources(dir, projectName, stmts, results);
     return results;
 }

package/build/tools/sync.js

@@ -6,7 +6,7 @@ import { indexProject } from "../indexer/project.js";
 import { computeDiff } from "../retrieval/context.js";
 import { decompress } from "../store/content.js";
 import { implicitRewardFromSync } from "../memory/experience.js";
-const SUPPORTED_EXTS = new Set([".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".rs"]);
+const SUPPORTED_EXTS = new Set([".ts", ".tsx", ".js", ".jsx", ".vue", ".py", ".go", ".rs"]);
 // ---------------------------------------------------------------------------
 // sync_file
 // ---------------------------------------------------------------------------

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a13xu/lucid",
-  "version": "1.9.2",
+  "version": "1.9.5",
   "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": {
@@ -39,17 +39,20 @@
     "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": "^11.0.0",
+    "better-sqlite3": "^12.0.0",
     "zod": "^3.23.8"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.11",
-    "@types/node": "^20.0.0",
+    "@types/node": "^22.0.0",
     "typescript": "^5.4.0"
   }
 }