@memextend/claude-code 0.1.0

package/dist/hooks/session-start.cjs

@@ -0,0 +1,1054 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/hooks/session-start.ts
+var import_crypto = require("crypto");
+var import_fs3 = require("fs");
+var import_promises3 = require("fs/promises");
+var import_path3 = require("path");
+var import_os2 = require("os");
+var import_child_process = require("child_process");
+
+// ../../core/dist/storage/sqlite.js
+var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
+var SQLiteStorage = class {
+  db;
+  constructor(dbPath) {
+    this.db = new import_better_sqlite3.default(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.initialize();
+  }
+  initialize() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS memories (
+        id TEXT PRIMARY KEY,
+        project_id TEXT,
+        content TEXT NOT NULL,
+        type TEXT NOT NULL,
+        source_tool TEXT,
+        created_at TEXT NOT NULL,
+        session_id TEXT,
+        metadata TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS projects (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        path TEXT NOT NULL,
+        created_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS global_profile (
+        id TEXT PRIMARY KEY,
+        key TEXT NOT NULL,
+        content TEXT NOT NULL,
+        created_at TEXT NOT NULL
+      );
+
+      CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+        content,
+        content='memories',
+        content_rowid='rowid'
+      );
+
+      CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
+        INSERT INTO memories_fts(rowid, content) VALUES (NEW.rowid, NEW.content);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
+        INSERT INTO memories_fts(memories_fts, rowid, content) VALUES('delete', OLD.rowid, OLD.content);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
+        INSERT INTO memories_fts(memories_fts, rowid, content) VALUES('delete', OLD.rowid, OLD.content);
+        INSERT INTO memories_fts(rowid, content) VALUES (NEW.rowid, NEW.content);
+      END;
+    `);
+  }
+  getTables() {
+    const rows = this.db.prepare(`
+      SELECT name FROM sqlite_master
+      WHERE type='table' OR type='virtual table'
+    `).all();
+    return rows.map((r) => r.name);
+  }
+  insertMemory(memory) {
+    const stmt = this.db.prepare(`
+      INSERT INTO memories (id, project_id, content, type, source_tool, created_at, session_id, metadata)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(memory.id, memory.projectId, memory.content, memory.type, memory.sourceTool, memory.createdAt, memory.sessionId, memory.metadata ? JSON.stringify(memory.metadata) : null);
+  }
+  getMemory(id) {
+    const row = this.db.prepare("SELECT * FROM memories WHERE id = ?").get(id);
+    if (!row)
+      return null;
+    return this.rowToMemory(row);
+  }
+  getAllMemories(projectId, limit = 100) {
+    let query = "SELECT * FROM memories";
+    const params = [];
+    if (projectId) {
+      query += " WHERE project_id = ?";
+      params.push(projectId);
+    }
+    query += " ORDER BY created_at DESC LIMIT ?";
+    params.push(limit);
+    const rows = this.db.prepare(query).all(...params);
+    return rows.map((row) => this.rowToMemory(row));
+  }
+  searchFTS(query, limit = 10) {
+    const rows = this.db.prepare(`
+      SELECT m.*, bm25(memories_fts) as score
+      FROM memories_fts fts
+      JOIN memories m ON m.rowid = fts.rowid
+      WHERE memories_fts MATCH ?
+      ORDER BY score
+      LIMIT ?
+    `).all(query, limit);
+    return rows.map((row) => ({
+      memory: this.rowToMemory(row),
+      score: Math.abs(row.score),
+      source: "fts"
+    }));
+  }
+  getRecentMemories(projectId, limit = 0, days = 0) {
+    let query = "SELECT * FROM memories";
+    const params = [];
+    const conditions = [];
+    if (days > 0) {
+      const cutoff = /* @__PURE__ */ new Date();
+      cutoff.setDate(cutoff.getDate() - days);
+      conditions.push("created_at > ?");
+      params.push(cutoff.toISOString());
+    }
+    if (projectId !== null) {
+      conditions.push("project_id = ?");
+      params.push(projectId);
+    }
+    if (conditions.length > 0) {
+      query += " WHERE " + conditions.join(" AND ");
+    }
+    query += " ORDER BY created_at DESC";
+    if (limit > 0) {
+      query += " LIMIT ?";
+      params.push(limit);
+    }
+    const rows = this.db.prepare(query).all(...params);
+    return rows.map((row) => this.rowToMemory(row));
+  }
+  deleteMemory(id) {
+    const result = this.db.prepare("DELETE FROM memories WHERE id = ?").run(id);
+    return result.changes > 0;
+  }
+  updateMemory(id, content) {
+    const result = this.db.prepare("UPDATE memories SET content = ? WHERE id = ?").run(content, id);
+    return result.changes > 0;
+  }
+  deleteAllMemories(projectId) {
+    if (projectId) {
+      const result = this.db.prepare("DELETE FROM memories WHERE project_id = ?").run(projectId);
+      return result.changes;
+    } else {
+      const result = this.db.prepare("DELETE FROM memories").run();
+      return result.changes;
+    }
+  }
+  deleteMemoriesBefore(date, projectId) {
+    const timestamp = date.toISOString();
+    if (projectId) {
+      const result = this.db.prepare("DELETE FROM memories WHERE created_at < ? AND project_id = ?").run(timestamp, projectId);
+      return result.changes;
+    } else {
+      const result = this.db.prepare("DELETE FROM memories WHERE created_at < ?").run(timestamp);
+      return result.changes;
+    }
+  }
+  // Project methods
+  insertProject(project) {
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO projects (id, name, path, created_at)
+      VALUES (?, ?, ?, ?)
+    `);
+    stmt.run(project.id, project.name, project.path, project.createdAt);
+  }
+  getProject(id) {
+    const row = this.db.prepare("SELECT * FROM projects WHERE id = ?").get(id);
+    if (!row)
+      return null;
+    return {
+      id: row.id,
+      name: row.name,
+      path: row.path,
+      createdAt: row.created_at
+    };
+  }
+  /**
+   * Find a project by name (case-insensitive).
+   * Returns the first matching project, preferring projects with a path set.
+   */
+  getProjectByName(name) {
+    const rowWithPath = this.db.prepare("SELECT * FROM projects WHERE LOWER(name) = LOWER(?) AND path != '' ORDER BY created_at ASC LIMIT 1").get(name);
+    if (rowWithPath) {
+      return {
+        id: rowWithPath.id,
+        name: rowWithPath.name,
+        path: rowWithPath.path,
+        createdAt: rowWithPath.created_at
+      };
+    }
+    const row = this.db.prepare("SELECT * FROM projects WHERE LOWER(name) = LOWER(?) ORDER BY created_at ASC LIMIT 1").get(name);
+    if (!row)
+      return null;
+    return {
+      id: row.id,
+      name: row.name,
+      path: row.path,
+      createdAt: row.created_at
+    };
+  }
+  /**
+   * Delete a project and all its memories.
+   * @returns Object with counts of deleted project and memories
+   */
+  deleteProject(projectId) {
+    const memoriesResult = this.db.prepare("DELETE FROM memories WHERE project_id = ?").run(projectId);
+    const projectResult = this.db.prepare("DELETE FROM projects WHERE id = ?").run(projectId);
+    return {
+      projectDeleted: projectResult.changes > 0,
+      memoriesDeleted: memoriesResult.changes
+    };
+  }
+  /**
+   * Get all projects.
+   */
+  getAllProjects() {
+    const rows = this.db.prepare("SELECT * FROM projects ORDER BY name ASC").all();
+    return rows.map((row) => ({
+      id: row.id,
+      name: row.name,
+      path: row.path,
+      createdAt: row.created_at
+    }));
+  }
+  // Global profile methods
+  insertGlobalProfile(profile) {
+    const stmt = this.db.prepare(`
+      INSERT INTO global_profile (id, key, content, created_at)
+      VALUES (?, ?, ?, ?)
+    `);
+    stmt.run(profile.id, profile.key, profile.content, profile.createdAt);
+  }
+  getGlobalProfiles(limit = 10) {
+    const rows = this.db.prepare(`
+      SELECT * FROM global_profile ORDER BY created_at DESC LIMIT ?
+    `).all(limit);
+    return rows.map((row) => ({
+      id: row.id,
+      key: row.key,
+      content: row.content,
+      createdAt: row.created_at
+    }));
+  }
+  /**
+   * Delete a specific global profile by ID.
+   */
+  deleteGlobalProfile(id) {
+    const result = this.db.prepare("DELETE FROM global_profile WHERE id = ?").run(id);
+    return result.changes > 0;
+  }
+  /**
+   * Delete all global profiles.
+   * @returns Number of profiles deleted
+   */
+  deleteAllGlobalProfiles() {
+    const result = this.db.prepare("DELETE FROM global_profile").run();
+    return result.changes;
+  }
+  getMemoryCount() {
+    const row = this.db.prepare("SELECT COUNT(*) as count FROM memories").get();
+    return row.count;
+  }
+  getMemoryCountByProject(projectId) {
+    const row = this.db.prepare("SELECT COUNT(*) as count FROM memories WHERE project_id = ?").get(projectId);
+    return row.count;
+  }
+  /**
+   * Get IDs of oldest memories for a project, exceeding the limit
+   * @returns Array of memory IDs to delete (oldest first)
+   */
+  getOldestMemoryIds(projectId, limit) {
+    let query;
+    let params;
+    if (projectId) {
+      query = `
+        SELECT id FROM memories
+        WHERE project_id = ?
+        ORDER BY created_at ASC
+        LIMIT ?
+      `;
+      params = [projectId, limit];
+    } else {
+      query = `
+        SELECT id FROM memories
+        ORDER BY created_at ASC
+        LIMIT ?
+      `;
+      params = [limit];
+    }
+    const rows = this.db.prepare(query).all(...params);
+    return rows.map((row) => row.id);
+  }
+  /**
+   * Prune memories to stay within limits
+   * @returns Number of memories deleted
+   */
+  pruneMemories(options) {
+    const deletedIds = [];
+    if (options.maxPerProject && options.maxPerProject > 0 && options.projectId) {
+      const count = this.getMemoryCountByProject(options.projectId);
+      if (count > options.maxPerProject) {
+        const excess = count - options.maxPerProject;
+        const idsToDelete = this.getOldestMemoryIds(options.projectId, excess);
+        for (const id of idsToDelete) {
+          this.deleteMemory(id);
+          deletedIds.push(id);
+        }
+      }
+    }
+    if (options.maxTotal && options.maxTotal > 0) {
+      const count = this.getMemoryCount();
+      if (count > options.maxTotal) {
+        const excess = count - options.maxTotal;
+        const idsToDelete = this.getOldestMemoryIds(null, excess);
+        for (const id of idsToDelete) {
+          if (!deletedIds.includes(id)) {
+            this.deleteMemory(id);
+            deletedIds.push(id);
+          }
+        }
+      }
+    }
+    return { deleted: deletedIds.length, deletedIds };
+  }
+  rowToMemory(row) {
+    return {
+      id: row.id,
+      projectId: row.project_id,
+      content: row.content,
+      type: row.type,
+      sourceTool: row.source_tool,
+      createdAt: row.created_at,
+      sessionId: row.session_id,
+      metadata: row.metadata ? JSON.parse(row.metadata) : null
+    };
+  }
+  close() {
+    this.db.close();
+  }
+};
+
+// ../../core/dist/storage/lancedb.js
+var lancedb = __toESM(require("@lancedb/lancedb"), 1);
+var LanceDBStorage = class _LanceDBStorage {
+  db;
+  table = null;
+  tableName = "memories";
+  dimensions = 384;
+  constructor(db) {
+    this.db = db;
+  }
+  static async create(dbPath) {
+    const db = await lancedb.connect(dbPath);
+    const storage = new _LanceDBStorage(db);
+    await storage.initialize();
+    return storage;
+  }
+  async initialize() {
+    const tableNames = await this.db.tableNames();
+    if (tableNames.includes(this.tableName)) {
+      this.table = await this.db.openTable(this.tableName);
+    }
+  }
+  async insertVector(id, vector) {
+    if (vector.length !== this.dimensions) {
+      throw new Error(`Vector must have ${this.dimensions} dimensions, got ${vector.length}`);
+    }
+    const data = [{ id, vector }];
+    if (!this.table) {
+      this.table = await this.db.createTable(this.tableName, data);
+    } else {
+      await this.table.add(data);
+    }
+  }
+  async insertVectors(items) {
+    for (const item of items) {
+      if (item.vector.length !== this.dimensions) {
+        throw new Error(`Vector must have ${this.dimensions} dimensions, got ${item.vector.length}`);
+      }
+    }
+    if (!this.table) {
+      this.table = await this.db.createTable(this.tableName, items);
+    } else {
+      await this.table.add(items);
+    }
+  }
+  async search(vector, limit = 10) {
+    if (!this.table) {
+      return [];
+    }
+    const effectiveLimit = limit > 0 ? limit : 100;
+    const results = await this.table.vectorSearch(vector).limit(effectiveLimit).toArray();
+    return results.map((row) => ({
+      id: row.id,
+      score: 1 - row._distance
+      // Convert distance to similarity
+    }));
+  }
+  async deleteVector(id) {
+    if (!this.table)
+      return;
+    const sanitizedId = id.replace(/'/g, "''");
+    await this.table.delete(`id = '${sanitizedId}'`);
+  }
+  async getVectorCount() {
+    if (!this.table)
+      return 0;
+    return await this.table.countRows();
+  }
+  async getVectorsByIds(ids) {
+    const result = /* @__PURE__ */ new Map();
+    if (!this.table || ids.length === 0)
+      return result;
+    const BATCH_SIZE = 100;
+    try {
+      for (let i = 0; i < ids.length; i += BATCH_SIZE) {
+        const batch = ids.slice(i, i + BATCH_SIZE);
+        const sanitizedIds = batch.map((id) => id.replace(/'/g, "''"));
+        const filter = sanitizedIds.map((id) => `id = '${id}'`).join(" OR ");
+        const rows = await this.table.query().where(filter).toArray();
+        for (const row of rows) {
+          result.set(row.id, row.vector);
+        }
+      }
+    } catch {
+    }
+    return result;
+  }
+  async close() {
+  }
+};
+
+// ../../core/dist/embedding/local.js
+var import_path = require("path");
+var import_fs = require("fs");
+var import_promises = require("fs/promises");
+var import_promises2 = require("stream/promises");
+var MODEL_URL = "https://huggingface.co/nomic-ai/nomic-embed-text-v1.5-GGUF/resolve/main/nomic-embed-text-v1.5.Q8_0.gguf";
+var MODEL_FILENAME = "nomic-embed-text-v1.5.Q8_0.gguf";
+var LocalEmbedding = class _LocalEmbedding {
+  // Using any to avoid ESM/CJS type issues with dynamic imports
+  model;
+  context;
+  dimensions;
+  constructor(model, context, dimensions) {
+    this.model = model;
+    this.context = context;
+    this.dimensions = dimensions;
+  }
+  static async create(modelsDir) {
+    const modelPath = (0, import_path.join)(modelsDir, MODEL_FILENAME);
+    if (!(0, import_fs.existsSync)(modelPath)) {
+      await _LocalEmbedding.downloadModel(modelsDir, modelPath);
+    }
+    const { getLlama, LlamaLogLevel } = await import("node-llama-cpp");
+    const llama = await getLlama({
+      logLevel: LlamaLogLevel.error
+      // Only show errors, not warnings
+    });
+    const model = await llama.loadModel({ modelPath });
+    const context = await model.createEmbeddingContext();
+    return new _LocalEmbedding(model, context, 384);
+  }
+  static async downloadModel(modelsDir, modelPath) {
+    await (0, import_promises.mkdir)(modelsDir, { recursive: true });
+    console.log(`Downloading embedding model to ${modelPath}...`);
+    console.log("This is a one-time download (~274MB)");
+    const response = await fetch(MODEL_URL);
+    if (!response.ok || !response.body) {
+      throw new Error(`Failed to download model: ${response.statusText}`);
+    }
+    const fileStream = (0, import_fs.createWriteStream)(modelPath);
+    await (0, import_promises2.pipeline)(response.body, fileStream);
+    console.log("Model downloaded successfully");
+  }
+  /**
+   * Generate embedding for a document/memory
+   */
+  async embed(text) {
+    const prefixedText = `search_document: ${text}`;
+    const embedding = await this.context.getEmbeddingFor(prefixedText);
+    const vector = Array.from(embedding.vector).slice(0, this.dimensions);
+    return this.normalize(vector);
+  }
+  /**
+   * Generate embedding for a search query
+   */
+  async embedQuery(text) {
+    const prefixedText = `search_query: ${text}`;
+    const embedding = await this.context.getEmbeddingFor(prefixedText);
+    const vector = Array.from(embedding.vector).slice(0, this.dimensions);
+    return this.normalize(vector);
+  }
+  /**
+   * Batch embed multiple texts (documents)
+   */
+  async embedBatch(texts) {
+    const results = [];
+    for (const text of texts) {
+      results.push(await this.embed(text));
+    }
+    return results;
+  }
+  /**
+   * Get the embedding dimensions
+   */
+  getDimensions() {
+    return this.dimensions;
+  }
+  /**
+   * Normalize vector to unit length (for cosine similarity)
+   */
+  normalize(vector) {
+    const norm = Math.sqrt(vector.reduce((sum, v) => sum + v * v, 0));
+    if (norm === 0)
+      return vector;
+    return vector.map((v) => v / norm);
+  }
+  async close() {
+    await this.context.dispose();
+  }
+};
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) {
+    throw new Error(`Vector dimensions must match: ${a.length} vs ${b.length}`);
+  }
+  let dot = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+  }
+  return dot;
+}
+function isModelAvailable(modelsDir) {
+  const modelPath = (0, import_path.join)(modelsDir, MODEL_FILENAME);
+  return (0, import_fs.existsSync)(modelPath);
+}
+async function createEmbedFunction(modelsDir) {
+  if (isModelAvailable(modelsDir)) {
+    try {
+      const embedding = await LocalEmbedding.create(modelsDir);
+      return {
+        embed: (text) => embedding.embed(text),
+        embedQuery: (text) => embedding.embedQuery(text),
+        isReal: true,
+        close: () => embedding.close()
+      };
+    } catch (error) {
+      console.error("[memextend] Failed to load embedding model, using fallback:", error);
+    }
+  }
+  const { createHash: createHash2 } = await import("crypto");
+  const hashEmbed = (text, prefix) => {
+    const hash = createHash2("sha256").update(prefix + text).digest();
+    const vector = Array.from(hash).slice(0, 32);
+    const expanded = [];
+    for (let i = 0; i < 12; i++) {
+      const roundHash = createHash2("sha256").update(text + i.toString()).digest();
+      expanded.push(...Array.from(roundHash).slice(0, 32));
+    }
+    const norm = Math.sqrt(expanded.reduce((sum, v) => sum + v * v, 0));
+    return expanded.map((v) => v / norm / 255);
+  };
+  return {
+    embed: async (text) => hashEmbed(text, "doc:"),
+    embedQuery: async (text) => hashEmbed(text, "query:"),
+    isReal: false,
+    close: async () => {
+    }
+  };
+}
+
+// ../../core/dist/memory/retrieve.js
+var MemoryRetriever = class {
+  sqlite;
+  lancedb;
+  embed;
+  options;
+  constructor(sqlite, lancedb2, embed, options = {}) {
+    this.sqlite = sqlite;
+    this.lancedb = lancedb2;
+    this.embed = embed;
+    this.options = {
+      defaultLimit: options.defaultLimit ?? 0,
+      // 0 = unlimited
+      defaultRecentDays: options.defaultRecentDays ?? 0,
+      // 0 = unlimited
+      rrfK: options.rrfK ?? 60
+    };
+  }
+  /**
+   * Full-text search using FTS5
+   */
+  async search(query, options = {}) {
+    const limit = options.limit ?? this.options.defaultLimit;
+    return this.sqlite.searchFTS(query, limit);
+  }
+  /**
+   * Vector similarity search using LanceDB
+   */
+  async vectorSearch(query, options = {}) {
+    const limit = options.limit ?? this.options.defaultLimit;
+    const queryVector = await this.embed(query);
+    const vectorResults = await this.lancedb.search(queryVector, limit * 2);
+    const results = [];
+    for (const vr of vectorResults) {
+      const memory = this.sqlite.getMemory(vr.id);
+      if (memory) {
+        if (options.projectId && memory.projectId !== options.projectId) {
+          continue;
+        }
+        results.push({
+          memory,
+          score: vr.score,
+          source: "vector"
+        });
+      }
+    }
+    return results.slice(0, limit);
+  }
+  /**
+   * Hybrid search combining FTS and vector search with RRF fusion
+   */
+  async hybridSearch(query, options = {}) {
+    const limit = options.limit ?? this.options.defaultLimit;
+    const k = this.options.rrfK;
+    const [ftsResults, vectorResults] = await Promise.all([
+      this.search(query, { ...options, limit: limit * 2 }),
+      this.vectorSearch(query, { ...options, limit: limit * 2 })
+    ]);
+    const scores = /* @__PURE__ */ new Map();
+    const memories = /* @__PURE__ */ new Map();
+    ftsResults.forEach((result, rank) => {
+      const rrfScore = 1 / (k + rank + 1);
+      scores.set(result.memory.id, (scores.get(result.memory.id) ?? 0) + rrfScore);
+      memories.set(result.memory.id, result.memory);
+    });
+    vectorResults.forEach((result, rank) => {
+      const rrfScore = 1 / (k + rank + 1);
+      scores.set(result.memory.id, (scores.get(result.memory.id) ?? 0) + rrfScore);
+      memories.set(result.memory.id, result.memory);
+    });
+    const combined = Array.from(scores.entries()).sort((a, b) => b[1] - a[1]).slice(0, limit).map(([id, score]) => ({
+      memory: memories.get(id),
+      score,
+      source: "hybrid"
+    }));
+    return combined;
+  }
+  /**
+   * Get recent memories for a project
+   */
+  getRecent(projectId, options = {}) {
+    const limit = options.limit ?? this.options.defaultLimit;
+    const days = options.recentDays ?? this.options.defaultRecentDays;
+    return this.sqlite.getRecentMemories(projectId, limit, days);
+  }
+  /**
+   * Get context for a new session - combines recent memories and global profile
+   */
+  async getContextForSession(projectId, options = {}) {
+    const limit = options.limit ?? this.options.defaultLimit;
+    const includeGlobal = options.includeGlobal ?? true;
+    const recentMemories = this.getRecent(projectId, {
+      limit: Math.floor(limit / 2),
+      recentDays: options.recentDays
+    });
+    const globalProfile = includeGlobal ? this.sqlite.getGlobalProfiles(5) : [];
+    const project = this.sqlite.getProject(projectId);
+    const projectName = project?.name ?? "project";
+    const relevantMemories = await this.vectorSearch(projectName, {
+      projectId,
+      limit: Math.floor(limit / 2)
+    });
+    return {
+      recentMemories,
+      globalProfile,
+      relevantMemories
+    };
+  }
+};
+function formatContextForInjection(context, options = {}) {
+  const maxChars = options.maxChars ?? 0;
+  const previewLength = options.previewLength ?? 200;
+  const lines = ["<memextend-context>", "## Your Memory for This Project", ""];
+  let currentLength = lines.join("\n").length;
+  const footer = [
+    "Use these memories naturally. Use `memextend_search` to find more details.",
+    "Use `memextend_save` to remember important decisions for future sessions.",
+    "</memextend-context>"
+  ].join("\n");
+  const footerLength = footer.length + 1;
+  const canAdd = (text) => {
+    if (maxChars === 0)
+      return true;
+    return currentLength + text.length + footerLength <= maxChars;
+  };
+  if (context.recentMemories.length > 0) {
+    const sectionHeader = "### Recent Work\n";
+    if (canAdd(sectionHeader)) {
+      lines.push("### Recent Work");
+      currentLength += sectionHeader.length;
+      for (const memory of context.recentMemories) {
+        const date = formatRelativeDate(memory.createdAt);
+        const preview = memory.content.split("\n")[0].slice(0, previewLength);
+        const line = `- [${date}] ${preview}
+`;
+        if (!canAdd(line))
+          break;
+        lines.push(`- [${date}] ${preview}`);
+        currentLength += line.length;
+      }
+      lines.push("");
+      currentLength += 1;
+    }
+  }
+  if (context.globalProfile.length > 0) {
+    const sectionHeader = "### User Preferences (Global)\n";
+    if (canAdd(sectionHeader)) {
+      lines.push("### User Preferences (Global)");
+      currentLength += sectionHeader.length;
+      for (const profile of context.globalProfile) {
+        const line = `- ${profile.content}
+`;
+        if (!canAdd(line))
+          break;
+        lines.push(`- ${profile.content}`);
+        currentLength += line.length;
+      }
+      lines.push("");
+      currentLength += 1;
+    }
+  }
+  if (context.relevantMemories && context.relevantMemories.length > 0) {
+    const sectionHeader = "### Relevant Past Work\n";
+    if (canAdd(sectionHeader)) {
+      lines.push("### Relevant Past Work");
+      currentLength += sectionHeader.length;
+      for (const result of context.relevantMemories) {
+        const preview = result.memory.content.split("\n")[0].slice(0, previewLength);
+        const line = `- ${preview}
+`;
+        if (!canAdd(line))
+          break;
+        lines.push(`- ${preview}`);
+        currentLength += line.length;
+      }
+      lines.push("");
+    }
+  }
+  lines.push("Use these memories naturally. Use `memextend_search` to find more details.");
+  lines.push("Use `memextend_save` to remember important decisions for future sessions.");
+  lines.push("</memextend-context>");
+  return lines.join("\n");
+}
+function formatRelativeDate(isoDate) {
+  const date = new Date(isoDate);
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffDays = Math.floor(diffMs / (1e3 * 60 * 60 * 24));
+  if (diffDays === 0)
+    return "today";
+  if (diffDays === 1)
+    return "yesterday";
+  if (diffDays < 7)
+    return `${diffDays} days ago`;
+  if (diffDays < 30)
+    return `${Math.floor(diffDays / 7)} weeks ago`;
+  return `${Math.floor(diffDays / 30)} months ago`;
+}
+
+// ../../core/dist/memory/deduplicate.js
+var DEFAULT_THRESHOLD = 0.85;
+function deduplicateMemories(memories, vectors, options) {
+  if (memories.length === 0)
+    return [];
+  const threshold = options?.similarityThreshold ?? DEFAULT_THRESHOLD;
+  const sorted = [...memories].sort((a, b) => {
+    return new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime();
+  });
+  const selected = [];
+  const selectedVectors = [];
+  for (const memory of sorted) {
+    const vector = vectors.get(memory.id);
+    if (!vector) {
+      selected.push(memory);
+      continue;
+    }
+    let isDuplicate = false;
+    for (const selectedVector of selectedVectors) {
+      const similarity = cosineSimilarity(vector, selectedVector);
+      if (similarity > threshold) {
+        isDuplicate = true;
+        break;
+      }
+    }
+    if (!isDuplicate) {
+      selected.push(memory);
+      selectedVectors.push(vector);
+    }
+  }
+  return selected;
+}
+function getDeduplicationStats(originalCount, deduplicatedCount) {
+  const removed = originalCount - deduplicatedCount;
+  const percentage = originalCount > 0 ? Math.round(removed / originalCount * 100) : 0;
+  return { removed, percentage };
+}
+
+// src/hooks/logger.ts
+var import_fs2 = require("fs");
+var import_path2 = require("path");
+var import_os = require("os");
+var MEMEXTEND_DIR = (0, import_path2.join)((0, import_os.homedir)(), ".memextend");
+var LOGS_DIR = (0, import_path2.join)(MEMEXTEND_DIR, "logs");
+var CONFIG_PATH = (0, import_path2.join)(MEMEXTEND_DIR, "config.json");
+var debugEnabled = null;
+function isDebugEnabled() {
+  if (debugEnabled !== null)
+    return debugEnabled;
+  try {
+    if ((0, import_fs2.existsSync)(CONFIG_PATH)) {
+      const config = JSON.parse((0, import_fs2.readFileSync)(CONFIG_PATH, "utf-8"));
+      debugEnabled = config.debug === true;
+    } else {
+      debugEnabled = false;
+    }
+  } catch {
+    debugEnabled = false;
+  }
+  return debugEnabled;
+}
+function ensureLogsDir() {
+  if (!(0, import_fs2.existsSync)(LOGS_DIR)) {
+    (0, import_fs2.mkdirSync)(LOGS_DIR, { recursive: true });
+  }
+}
+function log(hook, message, data) {
+  if (!isDebugEnabled())
+    return;
+  try {
+    ensureLogsDir();
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const logFile = (0, import_path2.join)(LOGS_DIR, "hooks.log");
+    const entry = data ? `[${timestamp}] [${hook}] ${message} ${JSON.stringify(data)}
+` : `[${timestamp}] [${hook}] ${message}
+`;
+    (0, import_fs2.appendFileSync)(logFile, entry);
+  } catch {
+  }
+}
+function logError(hook, error) {
+  try {
+    ensureLogsDir();
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const logFile = (0, import_path2.join)(LOGS_DIR, "hooks.log");
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    const entry = `[${timestamp}] [${hook}] ERROR: ${errorMsg}
+`;
+    (0, import_fs2.appendFileSync)(logFile, entry);
+  } catch {
+  }
+}
+
+// src/hooks/session-start.ts
+var MEMEXTEND_DIR2 = (0, import_path3.join)((0, import_os2.homedir)(), ".memextend");
+var CONFIG_PATH2 = (0, import_path3.join)(MEMEXTEND_DIR2, "config.json");
+var DB_PATH = (0, import_path3.join)(MEMEXTEND_DIR2, "memextend.db");
+var VECTORS_PATH = (0, import_path3.join)(MEMEXTEND_DIR2, "vectors");
+var MODELS_PATH = (0, import_path3.join)(MEMEXTEND_DIR2, "models");
+async function main() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  const input = JSON.parse(Buffer.concat(chunks).toString());
+  log("SessionStart", "Hook fired", {
+    source: input.source,
+    session_id: input.session_id,
+    cwd: input.cwd
+  });
+  try {
+    if (!(0, import_fs3.existsSync)(DB_PATH)) {
+      log("SessionStart", "DB not found, skipping");
+      outputResult({});
+      return;
+    }
+    const config = await loadConfig();
+    if (!config.retrieval?.autoInject) {
+      log("SessionStart", "Auto-inject disabled in config");
+      outputResult({});
+      return;
+    }
+    const projectId = getProjectId2(input.cwd);
+    const sqlite = new SQLiteStorage(DB_PATH);
+    const lancedb2 = await LanceDBStorage.create(VECTORS_PATH);
+    const embedder = await createEmbedFunction(MODELS_PATH);
+    const retriever = new MemoryRetriever(sqlite, lancedb2, embedder.embedQuery, {
+      defaultLimit: config.retrieval?.maxMemories ?? 0,
+      defaultRecentDays: config.retrieval?.recentDays ?? 0
+    });
+    const project = sqlite.getProject(projectId);
+    if (!project) {
+      sqlite.insertProject({
+        id: projectId,
+        name: (0, import_path3.basename)(input.cwd),
+        path: input.cwd,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    const isPostCompact = input.source === "compact";
+    if (isPostCompact) {
+      log("SessionStart", "POST-COMPACT INJECTION - restoring context after compaction");
+    }
+    const configLimit = config.retrieval?.maxMemories ?? 0;
+    const effectiveLimit = configLimit === 0 ? 1e3 : configLimit;
+    const maxMemories = isPostCompact ? Math.min(effectiveLimit * 2, configLimit === 0 ? 1e3 : 100) : effectiveLimit;
+    log("SessionStart", "Retrieving memories", { maxMemories, isPostCompact, configLimit });
+    const context = await retriever.getContextForSession(projectId, {
+      includeGlobal: config.retrieval?.includeGlobal ?? true,
+      limit: maxMemories,
+      recentDays: config.retrieval?.recentDays ?? 0
+    });
+    const allMemories = [
+      ...context.recentMemories,
+      ...context.relevantMemories.map((r) => r.memory)
+    ];
+    const deduplicationThreshold = config.retrieval?.deduplicationThreshold ?? 0.85;
+    let deduplicatedMemories = allMemories;
+    if (allMemories.length > 1) {
+      const memoryIds = allMemories.map((m) => m.id);
+      const vectors = await lancedb2.getVectorsByIds(memoryIds);
+      if (vectors.size > 0) {
+        deduplicatedMemories = deduplicateMemories(allMemories, vectors, {
+          similarityThreshold: deduplicationThreshold
+        });
+        const stats = getDeduplicationStats(allMemories.length, deduplicatedMemories.length);
+        if (stats.removed > 0) {
+          log("SessionStart", "Deduplication removed similar memories", {
+            original: allMemories.length,
+            deduplicated: deduplicatedMemories.length,
+            removed: stats.removed,
+            percentage: stats.percentage
+          });
+        }
+      }
+    }
+    sqlite.close();
+    await lancedb2.close();
+    await embedder.close();
+    if (deduplicatedMemories.length === 0 && context.globalProfile.length === 0) {
+      log("SessionStart", "No memories to inject");
+      outputResult({});
+      return;
+    }
+    const recentIds = new Set(context.recentMemories.map((m) => m.id));
+    const deduplicatedContext = {
+      recentMemories: deduplicatedMemories.filter((m) => recentIds.has(m.id)),
+      globalProfile: context.globalProfile,
+      relevantMemories: deduplicatedMemories.filter((m) => !recentIds.has(m.id)).map((m) => ({ memory: m, score: 0, source: "hybrid" }))
+    };
+    log("SessionStart", "Injecting memories", {
+      recentCount: deduplicatedContext.recentMemories.length,
+      globalCount: deduplicatedContext.globalProfile.length,
+      relevantCount: deduplicatedContext.relevantMemories.length,
+      totalOriginal: allMemories.length,
+      totalDeduplicated: deduplicatedMemories.length
+    });
+    const maxChars = isPostCompact ? config.retrieval?.compactMaxChars ?? 2e3 : config.retrieval?.sessionMaxChars ?? 1e4;
+    const previewLength = isPostCompact ? 100 : 200;
+    let formattedContext = formatContextForInjection(deduplicatedContext, {
+      maxChars,
+      previewLength
+    });
+    log("SessionStart", "Formatted context", {
+      isPostCompact,
+      maxChars,
+      actualChars: formattedContext.length
+    });
+    if (isPostCompact) {
+      formattedContext = `[Context restored after compaction - the following memories were preserved from your session]
+
+${formattedContext}`;
+    }
+    outputResult({
+      hookSpecificOutput: {
+        hookEventName: "SessionStart",
+        additionalContext: formattedContext
+      }
+    });
+  } catch (error) {
+    logError("SessionStart", error);
+    console.error("[memextend] Session start error:", error);
+    outputResult({});
+  }
+}
+function getProjectId2(cwd) {
+  try {
+    const gitRoot = (0, import_child_process.execSync)("git rev-parse --show-toplevel", {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return (0, import_crypto.createHash)("sha256").update(gitRoot).digest("hex").slice(0, 16);
+  } catch {
+    return (0, import_crypto.createHash)("sha256").update(cwd).digest("hex").slice(0, 16);
+  }
+}
+async function loadConfig() {
+  try {
+    if ((0, import_fs3.existsSync)(CONFIG_PATH2)) {
+      const content = await (0, import_promises3.readFile)(CONFIG_PATH2, "utf-8");
+      return JSON.parse(content);
+    }
+  } catch {
+  }
+  return {};
+}
+function outputResult(result) {
+  console.log(JSON.stringify(result));
+}
+main().catch((error) => {
+  console.error("[memextend] Fatal error:", error);
+  process.exit(0);
+});