@memextend/cursor 0.1.0

package/dist/cli/capture.cjs

@@ -0,0 +1,776 @@
+#!/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/capture.ts
+var import_crypto = require("crypto");
+var import_fs2 = require("fs");
+var import_promises3 = require("fs/promises");
+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 () => {
+    }
+  };
+}
+
+// src/cli/capture.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 = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    const next = args[i + 1];
+    switch (arg) {
+      case "--content":
+      case "-c":
+        options.content = next;
+        i++;
+        break;
+      case "--file":
+      case "-f":
+        options.file = next;
+        i++;
+        break;
+      case "--stdin":
+      case "-i":
+        options.stdin = true;
+        break;
+      case "--workspace":
+      case "-w":
+        options.workspace = next;
+        i++;
+        break;
+      case "--type":
+      case "-t":
+        options.type = next;
+        i++;
+        break;
+      case "--source":
+      case "-s":
+        options.sourceTool = next;
+        i++;
+        break;
+      case "--session":
+        options.sessionId = next;
+        i++;
+        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-capture - Capture session content to memory
+
+USAGE:
+  memextend-cursor-capture [OPTIONS]
+
+OPTIONS:
+  -c, --content <text>    Content to capture directly
+  -f, --file <path>       Read content from file
+  -i, --stdin             Read content from stdin
+  -w, --workspace <dir>   Workspace directory (default: cwd)
+  -t, --type <type>       Memory type: summary, tool_capture, manual (default: manual)
+  -s, --source <tool>     Source tool name (for tool_capture type)
+      --session <id>      Session ID for grouping captures
+  -q, --quiet             Suppress output
+  -h, --help              Show this help
+
+EXAMPLES:
+  # Capture direct content
+  memextend-cursor-capture -c "Implemented Redis caching for user sessions"
+
+  # Capture from file
+  memextend-cursor-capture -f session-notes.txt
+
+  # Capture from pipe (e.g., from AI output)
+  echo "Fixed authentication bug" | memextend-cursor-capture --stdin
+
+  # Capture with workspace context
+  memextend-cursor-capture -c "Added API endpoints" -w /path/to/project
+
+INTEGRATION:
+  Add as a Cursor task in tasks.json or bind to a keyboard shortcut.
+`);
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+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 main() {
+  const options = parseArgs();
+  if (!(0, import_fs2.existsSync)(DB_PATH)) {
+    console.error("Error: memextend not initialized. Run `memextend init` first.");
+    process.exit(1);
+  }
+  let content;
+  if (options.content) {
+    content = options.content;
+  } else if (options.file) {
+    if (!(0, import_fs2.existsSync)(options.file)) {
+      console.error(`Error: File not found: ${options.file}`);
+      process.exit(1);
+    }
+    content = await (0, import_promises3.readFile)(options.file, "utf-8");
+  } else if (options.stdin) {
+    content = await readStdin();
+  } else {
+    console.error("Error: No content source specified. Use --content, --file, or --stdin");
+    console.error("Run with --help for usage information.");
+    process.exit(1);
+  }
+  content = content.trim();
+  if (!content || content.length < 5) {
+    console.error("Error: Content is empty or too short (minimum 5 characters)");
+    process.exit(1);
+  }
+  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 project = sqlite.getProject(projectId);
+    if (!project) {
+      sqlite.insertProject({
+        id: projectId,
+        name: (0, import_path2.basename)(workspace),
+        path: workspace,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    const memoryId = (0, import_crypto.randomUUID)();
+    const memory = {
+      id: memoryId,
+      projectId,
+      content,
+      type: options.type ?? "manual",
+      sourceTool: options.sourceTool ?? null,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      sessionId: options.sessionId ?? null,
+      metadata: null
+    };
+    sqlite.insertMemory(memory);
+    const vector = await embedder.embed(content);
+    await lancedb2.insertVector(memoryId, vector);
+    if (!options.quiet) {
+      console.log(`Memory captured successfully!`);
+      console.log(`  ID: ${memoryId}`);
+      console.log(`  Project: ${(0, import_path2.basename)(workspace)}`);
+      console.log(`  Type: ${memory.type}`);
+      console.log(`  Content: ${content.slice(0, 100)}${content.length > 100 ? "..." : ""}`);
+    }
+  } finally {
+    sqlite.close();
+    await lancedb2.close();
+    await embedder.close();
+  }
+}
+main().catch((error) => {
+  console.error("Error:", error.message);
+  process.exit(1);
+});