@a13xu/lucid 1.9.2 → 1.9.4

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.4" }, { 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.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)) {
@@ -63,6 +93,10 @@ export function indexFile(filepath) {
         extracted = extractPython(source);
         language = "python";
     }
+    else if (ext === ".vue") {
+        extracted = extractVue(source);
+        language = "vue";
+    }
     else {
         extracted = extractGeneric(source);
         language = "generic";

package/build/indexer/project.js

@@ -181,9 +181,53 @@ 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);
@@ -204,6 +248,27 @@ function indexSourceFile(filepath, rootDir, projectName, stmts) {
                 exports.push(m[1]);
         }
     }
+    // Vue SFC — extract component name + defineExpose + named exports from <script>
+    if (lang === ".vue") {
+        // Component name from filename (always present)
+        exports.push(basename(filepath, ".vue"));
+        const scriptMatch = content.match(/<script[^>]*>([\s\S]*?)<\/script>/);
+        if (scriptMatch) {
+            const sc = scriptMatch[1];
+            // defineExpose({ foo, bar }) — what the component exposes to parents via template refs
+            const exposeMatch = sc.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]);
+                }
+            }
+            // Named exports (composables, types re-exported from SFC)
+            for (const m of sc.matchAll(/export\s+(?:async\s+)?(?:function|class|const|type|interface)\s+(\w+)/g)) {
+                exports.push(m[1]);
+            }
+        }
+    }
     if (exports.length === 0)
         return [];
     // Cale relativă față de rădăcina proiectului
@@ -314,7 +379,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a13xu/lucid",
-  "version": "1.9.2",
+  "version": "1.9.4",
   "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": {
@@ -44,12 +44,12 @@
   },
   "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"
   }
 }