@a13xu/lucid 1.1.0 → 1.9.0

package/build/tools/init.js

@@ -0,0 +1,212 @@
+import { z } from "zod";
+import { resolve, join } from "path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { indexProject } from "../indexer/project.js";
+import { saveAdminConfig, loadAdminConfig, isAdminConfigured, sendTestAlert, } from "../security/alerts.js";
+export const InitProjectSchema = z.object({
+    directory: z.string().optional(),
+    // ── Admin alert configuration (asked once at project init) ──────────────
+    /** Display name of the security admin */
+    adminName: z.string().optional(),
+    /** Email address to send security alerts to */
+    adminEmail: z.string().email().optional(),
+    /** SMTP server hostname (e.g. smtp.gmail.com) */
+    smtpHost: z.string().optional(),
+    /** SMTP port: 587 (STARTTLS, default) or 465 (direct TLS) */
+    smtpPort: z.number().int().min(1).max(65535).optional(),
+    /** SMTP login username (often same as adminEmail) */
+    smtpUser: z.string().optional(),
+    /** "From" display name + address (e.g. "Lucid Security <alerts@co.com>") */
+    smtpFrom: z.string().optional(),
+    /** Generic HTTP webhook URL (receives JSON POST, HMAC-signed if LUCID_WEBHOOK_SECRET is set) */
+    webhookUrl: z.string().url().optional(),
+    /** Slack incoming webhook URL */
+    slackWebhookUrl: z.string().url().optional(),
+    /** Which severities trigger an alert: default ["critical","high"] */
+    alertOn: z.array(z.enum(["critical", "high", "medium", "low"])).optional(),
+    /** Human-readable project name shown in alerts */
+    projectName: z.string().optional(),
+});
+const LUCID_MARKER = "Lucid: call sync_file";
+const LUCID_HOOK = {
+    matcher: { tools: ["Write", "Edit", "NotebookEdit"] },
+    hooks: [
+        {
+            type: "command",
+            command: `echo '🔄 ${LUCID_MARKER}(path) to keep knowledge graph up to date'`,
+        },
+    ],
+};
+function installHook(dir) {
+    const claudeDir = join(dir, ".claude");
+    const settingsPath = join(claudeDir, "settings.json");
+    let settings = {};
+    if (existsSync(settingsPath)) {
+        try {
+            settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+        }
+        catch {
+            return { installed: false, reason: "Could not parse .claude/settings.json" };
+        }
+    }
+    const hooks = (settings["hooks"] ?? {});
+    const postToolUse = hooks["PostToolUse"] ?? [];
+    // Detectează atât formatul vechi cât și cel nou
+    const alreadyInstalled = postToolUse.some((h) => {
+        const cmd = h.command ?? h.hooks?.[0]?.command ?? "";
+        return cmd.includes(LUCID_MARKER);
+    });
+    if (alreadyInstalled) {
+        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" };
+}
+// ---------------------------------------------------------------------------
+// Adaugă instrucțiune în CLAUDE.md
+// ---------------------------------------------------------------------------
+const LUCID_SYNC_INSTRUCTION = `
+<!-- LUCID_SYNC -->
+## 🔄 Lucid — Auto-sync after file changes
+
+After EVERY Write, Edit, or NotebookEdit tool call, you MUST immediately call:
+\`\`\`
+sync_file(path="<path of the file you just wrote/edited>")
+\`\`\`
+
+This keeps the Lucid knowledge graph up to date with the latest code.
+If multiple files changed (refactor, git pull), call sync_project() instead.
+<!-- /LUCID_SYNC -->
+`;
+function injectClaudeMdInstruction(dir) {
+    const claudeMdPath = join(dir, "CLAUDE.md");
+    if (!existsSync(claudeMdPath))
+        return false;
+    const content = readFileSync(claudeMdPath, "utf-8");
+    if (content.includes("LUCID_SYNC"))
+        return false; // already injected
+    writeFileSync(claudeMdPath, content.trimEnd() + "\n" + LUCID_SYNC_INSTRUCTION, "utf-8");
+    return true;
+}
+// ---------------------------------------------------------------------------
+// Main handler
+// ---------------------------------------------------------------------------
+export async function handleInitProject(stmts, input) {
+    const dir = resolve(input.directory ?? process.cwd());
+    const results = indexProject(dir, stmts);
+    const lines = [`✅ Project indexed: ${dir}`, ``];
+    if (results.length === 0) {
+        lines.push("No indexable files found.");
+        lines.push("Expected: CLAUDE.md, package.json, README.md, src/");
+    }
+    else {
+        lines.push(`Indexed ${results.length} source(s):`);
+        for (const r of results) {
+            lines.push(`  • [${r.type}] "${r.entity}" — ${r.observations} observation(s) from ${r.source}`);
+        }
+    }
+    // ── Hook PostToolUse ──────────────────────────────────────────────────────
+    lines.push(``);
+    const hookResult = installHook(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().`);
+    }
+    else {
+        lines.push(`🔗 Hook: ${hookResult.reason}`);
+    }
+    // ── CLAUDE.md injection ───────────────────────────────────────────────────
+    const injected = injectClaudeMdInstruction(dir);
+    if (injected) {
+        lines.push(`📋 CLAUDE.md updated with sync_file() instruction`);
+    }
+    // ── Security admin configuration ──────────────────────────────────────────
+    lines.push(``);
+    lines.push(`🔒 Security Alerts`);
+    // Save any admin params provided in this call
+    const adminFields = {
+        adminName: input.adminName,
+        adminEmail: input.adminEmail,
+        smtpHost: input.smtpHost,
+        smtpPort: input.smtpPort,
+        smtpUser: input.smtpUser,
+        smtpFrom: input.smtpFrom,
+        webhookUrl: input.webhookUrl,
+        slackWebhookUrl: input.slackWebhookUrl,
+        alertOn: input.alertOn,
+        projectName: input.projectName ?? results.find((r) => r.type === "project")?.entity,
+    };
+    const hasNewAdmin = Object.values(adminFields).some((v) => v !== undefined);
+    if (hasNewAdmin) {
+        // Strip undefined values before saving
+        const clean = Object.fromEntries(Object.entries(adminFields).filter(([, v]) => v !== undefined));
+        saveAdminConfig(dir, clean);
+        lines.push(`   Saved admin config → .claude/lucid-admin.json`);
+        // Test alert channels
+        const testResults = await sendTestAlert(dir);
+        lines.push(`   Test alert results:`);
+        for (const r of testResults)
+            lines.push(`     ${r}`);
+    }
+    else {
+        // Check existing config
+        const existing = loadAdminConfig(dir);
+        if (isAdminConfigured()) {
+            lines.push(`   Admin: ${existing.adminName ?? existing.adminEmail ?? "configured"}`);
+            lines.push(`   Channels: ${buildChannelSummary(existing)}`);
+            lines.push(`   Alerting on: ${(existing.alertOn ?? ["critical", "high"]).join(", ")}`);
+        }
+        else {
+            // Not configured — prompt user
+            lines.push(``);
+            lines.push(`   ⚠️  No security admin configured. Security alerts will only appear in logs.`);
+            lines.push(``);
+            lines.push(`   To enable alerts, re-run init_project() with admin parameters:`);
+            lines.push(``);
+            lines.push(`   Minimal (webhook only):`);
+            lines.push(`     init_project(`);
+            lines.push(`       adminName="Your Name",`);
+            lines.push(`       adminEmail="admin@yourcompany.com",`);
+            lines.push(`       webhookUrl="https://hooks.yourservice.com/...",`);
+            lines.push(`     )`);
+            lines.push(``);
+            lines.push(`   With Slack:`);
+            lines.push(`     init_project(`);
+            lines.push(`       adminName="Your Name",`);
+            lines.push(`       adminEmail="admin@yourcompany.com",`);
+            lines.push(`       slackWebhookUrl="https://hooks.slack.com/services/...",`);
+            lines.push(`     )`);
+            lines.push(``);
+            lines.push(`   With Email (SMTP):`);
+            lines.push(`     init_project(`);
+            lines.push(`       adminName="Your Name",`);
+            lines.push(`       adminEmail="admin@yourcompany.com",`);
+            lines.push(`       smtpHost="smtp.gmail.com",`);
+            lines.push(`       smtpPort=587,`);
+            lines.push(`       smtpUser="alerts@yourcompany.com",`);
+            lines.push(`     )`);
+            lines.push(`     # Then set in your environment:`);
+            lines.push(`     export LUCID_SMTP_PASS="your-app-password"`);
+            lines.push(``);
+            lines.push(`   SMTP password must be in LUCID_SMTP_PASS env var (never as a parameter).`);
+            lines.push(`   Webhook HMAC signing: set LUCID_WEBHOOK_SECRET env var.`);
+        }
+    }
+    lines.push(``);
+    lines.push(`From now on, call sync_file(path) after every file you write or edit.`);
+    lines.push(`Use recall() to query accumulated project knowledge.`);
+    return lines.join("\n");
+}
+function buildChannelSummary(cfg) {
+    const channels = [];
+    if (cfg.adminEmail && cfg.smtpHost)
+        channels.push(`email(${cfg.adminEmail})`);
+    if (cfg.webhookUrl)
+        channels.push(`webhook`);
+    if (cfg.slackWebhookUrl)
+        channels.push(`slack`);
+    return channels.length > 0 ? channels.join(", ") : "none";
+}

package/build/tools/remember.d.ts

@@ -5,13 +5,13 @@ export declare const RememberSchema: z.ZodObject<{
     entityType: z.ZodEnum<["person", "project", "decision", "pattern", "tool", "config", "bug", "convention"]>;
     observation: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    entity: string;
-    entityType: "person" | "project" | "decision" | "pattern" | "tool" | "config" | "bug" | "convention";
     observation: string;
-}, {
     entity: string;
-    entityType: "person" | "project" | "decision" | "pattern" | "tool" | "config" | "bug" | "convention";
+    entityType: "tool" | "pattern" | "person" | "project" | "decision" | "config" | "bug" | "convention";
+}, {
     observation: string;
+    entity: string;
+    entityType: "tool" | "pattern" | "person" | "project" | "decision" | "config" | "bug" | "convention";
 }>;
 export type RememberInput = z.infer<typeof RememberSchema>;
 export declare function remember(stmts: Statements, input: RememberInput): string;

package/build/tools/reward.d.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import type { Statements } from "../database.js";
+export declare const RewardSchema: z.ZodObject<{
+    note: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    note?: string | undefined;
+}, {
+    note?: string | undefined;
+}>;
+export declare const PenalizeSchema: z.ZodObject<{
+    note: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    note?: string | undefined;
+}, {
+    note?: string | undefined;
+}>;
+export declare const ShowRewardsSchema: z.ZodObject<{
+    query: z.ZodOptional<z.ZodString>;
+    topK: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    query?: string | undefined;
+    topK?: number | undefined;
+}, {
+    query?: string | undefined;
+    topK?: number | undefined;
+}>;
+export declare function handleReward(stmts: Statements, args: z.infer<typeof RewardSchema>): string;
+export declare function handlePenalize(stmts: Statements, args: z.infer<typeof PenalizeSchema>): string;
+export declare function handleShowRewards(stmts: Statements, args: z.infer<typeof ShowRewardsSchema>): string;

package/build/tools/reward.js

@@ -0,0 +1,154 @@
+// Reward / penalize / show_rewards tool handlers
+import { z } from "zod";
+import { getLastExperienceId, rewardExperience, decayedReward, } from "../memory/experience.js";
+// ---------------------------------------------------------------------------
+// Schemas
+// ---------------------------------------------------------------------------
+export const RewardSchema = z.object({
+    note: z.string().optional().describe("Optional note about what worked"),
+});
+export const PenalizeSchema = z.object({
+    note: z.string().optional().describe("Optional note about what was missing or wrong"),
+});
+export const ShowRewardsSchema = z.object({
+    query: z.string().optional().describe("Filter experiences by query text"),
+    topK: z.number().int().min(1).max(50).optional().describe("Number of top results to show (default 10)"),
+});
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function formatAge(unixSec) {
+    const diffSec = Math.floor(Date.now() / 1000) - unixSec;
+    if (diffSec < 3600)
+        return `${Math.round(diffSec / 60)}m ago`;
+    if (diffSec < 86400)
+        return `${Math.round(diffSec / 3600)}h ago`;
+    return `${Math.round(diffSec / 86400)} days ago`;
+}
+function parseFps(contextFps) {
+    try {
+        return JSON.parse(contextFps);
+    }
+    catch {
+        return [];
+    }
+}
+// ---------------------------------------------------------------------------
+// reward — explicit +1 on the last experience
+// ---------------------------------------------------------------------------
+export function handleReward(stmts, args) {
+    const lastId = getLastExperienceId();
+    if (lastId === null) {
+        return "❌ No recent get_context() call to reward. Call get_context() first.";
+    }
+    const result = rewardExperience(lastId, 1.0, args.note ?? null, stmts);
+    if (!result) {
+        return `❌ Experience #${lastId} not found in database.`;
+    }
+    const lines = [
+        `✅ Experience #${lastId} rewarded (+1)`,
+        `   Query: "${result.query}"`,
+    ];
+    if (args.note)
+        lines.push(`   Note: ${args.note}`);
+    if (result.fps.length > 0) {
+        lines.push(`   Rewarded files:`);
+        for (const fp of result.fps.slice(0, 5)) {
+            lines.push(`     +1.0  ${fp}`);
+        }
+        if (result.fps.length > 5)
+            lines.push(`     … and ${result.fps.length - 5} more`);
+    }
+    // Show accumulated reward for these files
+    const allRewards = stmts.getFileRewards.all();
+    const relevant = allRewards.filter((fr) => result.fps.includes(fr.filepath));
+    if (relevant.length > 0) {
+        const total = relevant.reduce((sum, fr) => sum + fr.total_reward, 0);
+        lines.push(`   Total reward score for these files: ${total.toFixed(1)} (accumulated)`);
+    }
+    return lines.join("\n");
+}
+// ---------------------------------------------------------------------------
+// penalize — explicit -1 on the last experience
+// ---------------------------------------------------------------------------
+export function handlePenalize(stmts, args) {
+    const lastId = getLastExperienceId();
+    if (lastId === null) {
+        return "❌ No recent get_context() call to penalize. Call get_context() first.";
+    }
+    const result = rewardExperience(lastId, -1.0, args.note ?? null, stmts);
+    if (!result) {
+        return `❌ Experience #${lastId} not found in database.`;
+    }
+    const lines = [
+        `❌ Experience #${lastId} penalized (-1)`,
+        `   Query: "${result.query}"`,
+    ];
+    if (args.note)
+        lines.push(`   Note: ${args.note}`);
+    if (result.fps.length > 0) {
+        lines.push(`   Penalized files:`);
+        for (const fp of result.fps.slice(0, 5)) {
+            lines.push(`     -1.0  ${fp}`);
+        }
+        if (result.fps.length > 5)
+            lines.push(`     … and ${result.fps.length - 5} more`);
+    }
+    return lines.join("\n");
+}
+// ---------------------------------------------------------------------------
+// show_rewards — display top experiences + most rewarded files
+// ---------------------------------------------------------------------------
+export function handleShowRewards(stmts, args) {
+    const topK = args.topK ?? 10;
+    const lines = [];
+    // Get experiences
+    let experiences;
+    if (args.query) {
+        try {
+            // FTS search: append * for prefix match
+            const ftsQuery = args.query.trim().split(/\s+/).map((t) => `${t}*`).join(" ");
+            experiences = stmts.searchExperiencesFTS.all(ftsQuery, topK);
+        }
+        catch {
+            // Fall back to top by reward if FTS query is malformed
+            experiences = stmts.getTopExperiences.all(topK);
+        }
+    }
+    else {
+        experiences = stmts.getTopExperiences.all(topK);
+    }
+    if (experiences.length === 0) {
+        lines.push("No rewarded experiences yet. Use get_context() then reward() to start building context memory.");
+    }
+    else {
+        lines.push("🏆 Top rewarded experiences (decayed):", "");
+        for (const exp of experiences) {
+            const decayed = decayedReward(exp.reward, exp.rewarded_at);
+            const ageStr = exp.rewarded_at ? formatAge(exp.rewarded_at) : "never rewarded";
+            const sign = exp.reward >= 0 ? "+" : "";
+            lines.push(`#${exp.id}  ${sign}${decayed.toFixed(1)}  "${exp.query}"  (${ageStr})`);
+            const fps = parseFps(exp.context_fps);
+            if (fps.length > 0) {
+                const shown = fps.slice(0, 3).join(", ");
+                const extra = fps.length > 3 ? ` +${fps.length - 3} more` : "";
+                lines.push(`     → ${shown}${extra}`);
+            }
+            if (exp.feedback)
+                lines.push(`     note: ${exp.feedback}`);
+        }
+    }
+    // Most rewarded files (decayed)
+    lines.push("", "📁 Most rewarded files:");
+    const topFiles = stmts.getTopFileRewards.all(topK);
+    if (topFiles.length === 0) {
+        lines.push("  (none yet)");
+    }
+    else {
+        topFiles.forEach((fr, i) => {
+            const decayed = decayedReward(fr.total_reward, fr.last_rewarded);
+            lines.push(`  ${i + 1}. ${fr.filepath}  reward=${decayed.toFixed(1)}  used=${fr.use_count}x`);
+        });
+    }
+    return lines.join("\n");
+}

package/build/tools/sync.d.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import type { Statements } from "../database.js";
+export declare const SyncFileSchema: z.ZodObject<{
+    path: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+}, {
+    path: string;
+}>;
+export declare function handleSyncFile(stmts: Statements, args: z.infer<typeof SyncFileSchema>): string;
+export declare const SyncProjectSchema: z.ZodObject<{
+    directory: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    directory?: string | undefined;
+}, {
+    directory?: string | undefined;
+}>;
+export declare function handleSyncProject(stmts: Statements, args: z.infer<typeof SyncProjectSchema>): string;

package/build/tools/sync.js

@@ -0,0 +1,76 @@
+import { z } from "zod";
+import { resolve, extname } from "path";
+import { existsSync, readFileSync } from "fs";
+import { indexFile, upsertFileIndex } from "../indexer/file.js";
+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"]);
+// ---------------------------------------------------------------------------
+// sync_file
+// ---------------------------------------------------------------------------
+export const SyncFileSchema = z.object({
+    path: z.string().min(1),
+});
+export function handleSyncFile(stmts, args) {
+    const filepath = resolve(args.path);
+    if (!existsSync(filepath))
+        return `File not found: ${filepath}`;
+    if (!SUPPORTED_EXTS.has(extname(filepath).toLowerCase())) {
+        return `Unsupported file type: ${extname(filepath)}. Supported: ${[...SUPPORTED_EXTS].join(", ")}`;
+    }
+    const index = indexFile(filepath);
+    if (!index)
+        return `Could not read file: ${filepath}`;
+    const source = readFileSync(filepath, "utf-8");
+    // Capture previous content before upsert (for diff)
+    const prevRow = stmts.getFileByPath.get(filepath);
+    const prevSource = prevRow ? decompress(prevRow.content) : null;
+    const result = upsertFileIndex(index, source, stmts);
+    if (!result.stored) {
+        return `⏭️  Unchanged: ${filepath} (hash match — skipped)`;
+    }
+    // Store diff when file changed
+    if (prevRow && prevSource !== null) {
+        const diff = computeDiff(prevSource, source);
+        stmts.upsertDiff.run(filepath, prevRow.content_hash, diff);
+    }
+    const ratio = Math.round((1 - (result.savedBytes + Buffer.byteLength(source, "utf-8") - result.savedBytes) / Buffer.byteLength(source, "utf-8")) * 100);
+    const saved = Math.round(result.savedBytes / 1024 * 10) / 10;
+    const lines = [
+        `✅ Synced: ${filepath}`,
+        `   exports: ${index.exports.join(", ") || "none"}`,
+        `   compressed: saved ${saved}KB`,
+    ];
+    if (index.description)
+        lines.push(`   description: ${index.description}`);
+    if (index.todos.length > 0)
+        lines.push(`   TODOs: ${index.todos.length} open`);
+    // Implicit reward: if this file was in the last get_context result → +0.3
+    const implicitRewarded = implicitRewardFromSync(filepath, stmts);
+    if (implicitRewarded)
+        lines.push(`   🎯 Implicit reward +0.3 (file was in recent context)`);
+    return lines.join("\n");
+}
+// ---------------------------------------------------------------------------
+// sync_project
+// ---------------------------------------------------------------------------
+export const SyncProjectSchema = z.object({
+    directory: z.string().optional(),
+});
+export function handleSyncProject(stmts, args) {
+    const dir = resolve(args.directory ?? process.cwd());
+    const results = indexProject(dir, stmts);
+    if (results.length === 0)
+        return `No changes indexed in: ${dir}`;
+    const stats = stmts.fileStorageStats.get();
+    const ratio = stats.total_original > 0
+        ? Math.round((1 - stats.total_compressed / stats.total_original) * 100)
+        : 0;
+    return [
+        `✅ Project re-synced: ${dir}`,
+        `   ${results.length} source(s) updated`,
+        `   Storage: ${Math.round(stats.total_compressed / 1024)}KB compressed / ${Math.round(stats.total_original / 1024)}KB original (${ratio}% saved)`,
+    ].join("\n");
+}

package/package.json

@@ -1,48 +1,55 @@
-{
-  "name": "@a13xu/lucid",
-  "version": "1.1.0",
-  "description": "Persistent memory for Claude Code agents — SQLite + FTS5 knowledge graph via MCP",
-  "type": "module",
-  "bin": {
-    "lucid": "./build/index.js"
-  },
-  "files": [
-    "build/**/*.js",
-    "build/**/*.d.ts",
-    "README.md"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "prepublishOnly": "npm run build"
-  },
-  "keywords": [
-    "mcp",
-    "claude",
-    "claude-code",
-    "memory",
-    "sqlite",
-    "knowledge-graph",
-    "ai",
-    "anthropic"
-  ],
-  "author": "a13xu",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/a13xu/lucid.git"
-  },
-  "homepage": "https://github.com/a13xu/lucid#readme",
-  "engines": {
-    "node": ">=18"
-  },
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0",
-    "better-sqlite3": "^11.0.0",
-    "zod": "^3.23.8"
-  },
-  "devDependencies": {
-    "@types/better-sqlite3": "^7.6.11",
-    "@types/node": "^20.0.0",
-    "typescript": "^5.4.0"
-  }
-}
+{
+  "name": "@a13xu/lucid",
+  "version": "1.9.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",
+    "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",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "better-sqlite3": "^11.0.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.11",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.4.0"
+  }
+}