@memextend/cursor 0.1.0

package/dist/cli/inject.cjs

@@ -0,0 +1,1029 @@
+#!/usr/bin/env node
+"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/cli/inject.ts
+var import_crypto = require("crypto");
+var import_fs2 = require("fs");
+var import_path2 = require("path");
+var import_os = 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 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`;
+}
+
+// src/cli/inject.ts
+var MEMEXTEND_DIR = (0, import_path2.join)((0, import_os.homedir)(), ".memextend");
+var DB_PATH = (0, import_path2.join)(MEMEXTEND_DIR, "memextend.db");
+var VECTORS_PATH = (0, import_path2.join)(MEMEXTEND_DIR, "vectors");
+var MODELS_PATH = (0, import_path2.join)(MEMEXTEND_DIR, "models");
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const options = {
+    includeGlobal: true,
+    format: "text"
+  };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    const next = args[i + 1];
+    switch (arg) {
+      case "--workspace":
+      case "-w":
+        options.workspace = next;
+        i++;
+        break;
+      case "--days":
+      case "-d":
+        options.days = parseInt(next, 10);
+        i++;
+        break;
+      case "--limit":
+      case "-l":
+        options.limit = parseInt(next, 10);
+        i++;
+        break;
+      case "--no-global":
+        options.includeGlobal = false;
+        break;
+      case "--format":
+      case "-f":
+        options.format = next;
+        i++;
+        break;
+      case "--clipboard":
+      case "-c":
+        options.clipboard = true;
+        break;
+      case "--quiet":
+      case "-q":
+        options.quiet = true;
+        break;
+      case "--help":
+      case "-h":
+        printHelp();
+        process.exit(0);
+    }
+  }
+  return options;
+}
+function printHelp() {
+  console.log(`
+memextend-cursor-inject - Retrieve context for session start
+
+USAGE:
+  memextend-cursor-inject [OPTIONS]
+
+OPTIONS:
+  -w, --workspace <dir>   Workspace directory (default: cwd)
+  -d, --days <n>          Look back N days (default: 7)
+  -l, --limit <n>         Maximum memories to retrieve (default: 10)
+      --no-global         Exclude global preferences
+  -f, --format <type>     Output format: text, json, markdown (default: text)
+  -c, --clipboard         Copy to clipboard (macOS only)
+  -q, --quiet             Only output the context (no status messages)
+  -h, --help              Show this help
+
+EXAMPLES:
+  # Get context for current workspace
+  memextend-cursor-inject
+
+  # Get context for specific project
+  memextend-cursor-inject -w /path/to/project
+
+  # Get extended history
+  memextend-cursor-inject --days 30 --limit 20
+
+  # Copy to clipboard for pasting into Cursor
+  memextend-cursor-inject --clipboard
+
+  # Get JSON for programmatic use
+  memextend-cursor-inject --format json
+
+INTEGRATION:
+  Run at session start or add to your shell profile.
+  Can be piped to Cursor's context via extensions or tasks.
+`);
+}
+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);
+  }
+}
+function copyToClipboard(text) {
+  try {
+    if (process.platform === "darwin") {
+      (0, import_child_process.execSync)("pbcopy", { input: text });
+      return true;
+    }
+    if (process.platform === "linux") {
+      (0, import_child_process.execSync)("xclip -selection clipboard", { input: text });
+      return true;
+    }
+    if (process.platform === "win32") {
+      (0, import_child_process.execSync)("clip", { input: text });
+      return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+async function main() {
+  const options = parseArgs();
+  if (!(0, import_fs2.existsSync)(DB_PATH)) {
+    if (!options.quiet) {
+      console.error("memextend not initialized. Run `memextend init` first.");
+    }
+    console.log("<memextend-context>\nNo memories available.\n</memextend-context>");
+    process.exit(0);
+  }
+  const workspace = options.workspace ? (0, import_path2.resolve)(options.workspace) : process.cwd();
+  const projectId = getProjectId2(workspace);
+  const sqlite = new SQLiteStorage(DB_PATH);
+  const lancedb2 = await LanceDBStorage.create(VECTORS_PATH);
+  const embedder = await createEmbedFunction(MODELS_PATH);
+  try {
+    const retriever = new MemoryRetriever(sqlite, lancedb2, embedder.embedQuery, {
+      defaultLimit: options.limit ?? 0,
+      defaultRecentDays: options.days ?? 0
+    });
+    const project = sqlite.getProject(projectId);
+    if (!project) {
+      sqlite.insertProject({
+        id: projectId,
+        name: (0, import_path2.basename)(workspace),
+        path: workspace,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    const context = await retriever.getContextForSession(projectId, {
+      includeGlobal: options.includeGlobal ?? true,
+      recentDays: options.days
+    });
+    const hasContent = context.recentMemories.length > 0 || context.globalProfile.length > 0 || context.relevantMemories && context.relevantMemories.length > 0;
+    let output;
+    if (options.format === "json") {
+      output = JSON.stringify({
+        projectId,
+        projectName: (0, import_path2.basename)(workspace),
+        workspace,
+        recentMemories: context.recentMemories,
+        globalProfile: context.globalProfile,
+        relevantMemories: context.relevantMemories,
+        hasContent
+      }, null, 2);
+    } else if (options.format === "markdown") {
+      if (!hasContent) {
+        output = `# Memory Context for ${(0, import_path2.basename)(workspace)}
+
+No memories found. This might be a new project.
+`;
+      } else {
+        output = formatContextAsMarkdown(context, (0, import_path2.basename)(workspace));
+      }
+    } else {
+      if (!hasContent) {
+        output = `<memextend-context>
+## Project: ${(0, import_path2.basename)(workspace)}
+
+No memories found. This might be a new project.
+</memextend-context>`;
+      } else {
+        output = formatContextForInjection(context);
+      }
+    }
+    if (options.clipboard) {
+      const copied = copyToClipboard(output);
+      if (!options.quiet) {
+        if (copied) {
+          console.error("Context copied to clipboard!");
+        } else {
+          console.error("Warning: Could not copy to clipboard");
+        }
+      }
+    }
+    console.log(output);
+  } finally {
+    sqlite.close();
+    await lancedb2.close();
+    await embedder.close();
+  }
+}
+function formatContextAsMarkdown(context, projectName) {
+  const lines = [`# Memory Context for ${projectName}`, ""];
+  if (context.recentMemories.length > 0) {
+    lines.push("## Recent Work");
+    lines.push("");
+    for (const memory of context.recentMemories) {
+      const date = new Date(memory.createdAt).toLocaleDateString();
+      lines.push(`### ${date}`);
+      lines.push("");
+      lines.push(memory.content);
+      lines.push("");
+    }
+  }
+  if (context.globalProfile.length > 0) {
+    lines.push("## User Preferences (Global)");
+    lines.push("");
+    for (const profile of context.globalProfile) {
+      lines.push(`- **${profile.key}**: ${profile.content}`);
+    }
+    lines.push("");
+  }
+  if (context.relevantMemories && context.relevantMemories.length > 0) {
+    lines.push("## Relevant Past Work");
+    lines.push("");
+    for (const result of context.relevantMemories) {
+      lines.push(`- ${result.memory.content.split("\n")[0].slice(0, 100)}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+main().catch((error) => {
+  console.error("Error:", error.message);
+  process.exit(1);
+});