@memextend/claude-code 0.1.0

package/dist/hooks/stop.cjs

@@ -0,0 +1,1059 @@
+"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/stop.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/capture.js
+var MIN_TEXT_LENGTH = 100;
+var DEFAULT_MAX_REASONING_LENGTH = 1e4;
+var DEFAULT_MAX_TOOL_OUTPUT_LENGTH = 2e3;
+var CONFIGURABLE_TOOLS = ["Edit", "Write", "Bash", "Task"];
+var DEFAULT_TOOL_CONFIG = {
+  Edit: false,
+  Write: false,
+  Bash: false,
+  Task: false
+};
+var TranscriptParser = class {
+  toolConfig;
+  maxReasoningLength;
+  maxToolOutputLength;
+  captureReasoning;
+  constructor(options = {}) {
+    if (options.toolConfig) {
+      this.toolConfig = { ...DEFAULT_TOOL_CONFIG, ...options.toolConfig };
+    } else if (options.captureTools) {
+      this.toolConfig = { ...DEFAULT_TOOL_CONFIG };
+      for (const tool of CONFIGURABLE_TOOLS) {
+        this.toolConfig[tool] = options.captureTools.has(tool);
+      }
+    } else {
+      this.toolConfig = { ...DEFAULT_TOOL_CONFIG };
+    }
+    if (options.maxContentLength !== void 0) {
+      this.maxReasoningLength = options.maxContentLength;
+      this.maxToolOutputLength = options.maxContentLength;
+    } else {
+      this.maxReasoningLength = options.maxReasoningLength ?? DEFAULT_MAX_REASONING_LENGTH;
+      this.maxToolOutputLength = options.maxToolOutputLength ?? DEFAULT_MAX_TOOL_OUTPUT_LENGTH;
+    }
+    this.captureReasoning = options.captureReasoning ?? true;
+  }
+  /**
+   * Parse a Claude Code JSONL transcript and extract captures
+   *
+   * Captures two types of content:
+   * 1. Claude's text responses (reasoning, explanations, decisions)
+   * 2. Tool calls for code changes (Edit, Write)
+   *
+   * Claude Code transcript format:
+   * - type: "assistant" with message.content containing text and tool_use objects
+   * - type: "user" with message.content containing tool_result objects
+   */
+  parse(transcript) {
+    const lines = transcript.trim().split("\n");
+    const captures = [];
+    const pendingToolUses = /* @__PURE__ */ new Map();
+    for (const line of lines) {
+      if (!line.trim())
+        continue;
+      try {
+        const entry = JSON.parse(line);
+        if (!entry.message?.content || typeof entry.message.content === "string") {
+          continue;
+        }
+        const contentArray = entry.message.content;
+        if (entry.type === "assistant") {
+          if (this.captureReasoning) {
+            for (const block of contentArray) {
+              if (block.type === "text" && block.text) {
+                const text = block.text.trim();
+                if (text.length >= MIN_TEXT_LENGTH && this.isSubstantialContent(text)) {
+                  captures.push({
+                    type: "reasoning",
+                    content: this.truncate(text, this.maxReasoningLength)
+                  });
+                }
+              }
+            }
+          }
+          for (const block of contentArray) {
+            if (block.type === "tool_use" && block.name && block.id && block.input) {
+              if (this.shouldCapture(block.name)) {
+                pendingToolUses.set(block.id, {
+                  tool: block.name,
+                  input: block.input
+                });
+              }
+            }
+          }
+        }
+        if (entry.type === "user") {
+          for (const block of contentArray) {
+            if (block.type === "tool_result" && block.tool_use_id) {
+              const pending = pendingToolUses.get(block.tool_use_id);
+              if (pending) {
+                let output = "";
+                if (typeof block.content === "string") {
+                  output = block.content;
+                } else if (Array.isArray(block.content)) {
+                  output = block.content.filter((c) => c.type === "text" && c.text).map((c) => c.text).join("\n");
+                }
+                captures.push({
+                  tool: pending.tool,
+                  input: pending.input,
+                  output: this.truncate(output, this.maxToolOutputLength)
+                });
+                pendingToolUses.delete(block.tool_use_id);
+              }
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    return captures;
+  }
+  /**
+   * Check if text content is substantial (not just filler/transitional)
+   */
+  isSubstantialContent(text) {
+    const skipPatterns = [
+      /^(let me|i'll|i will|now i|looking at|checking|searching)/i,
+      /^(here's|here is) (the|what|how)/i,
+      /^(done|completed|finished|success)/i,
+      /^(ok|okay|sure|yes|no|alright)/i
+    ];
+    for (const pattern of skipPatterns) {
+      if (pattern.test(text.slice(0, 50))) {
+        if (text.length < 200) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  /**
+   * Legacy method for backward compatibility - returns only tool captures
+   */
+  parseToolCaptures(transcript) {
+    return this.parse(transcript).filter((c) => "tool" in c);
+  }
+  shouldCapture(tool) {
+    if (CONFIGURABLE_TOOLS.includes(tool)) {
+      return this.toolConfig[tool] === true;
+    }
+    return false;
+  }
+  truncate(str, maxLen) {
+    if (str.length <= maxLen)
+      return str;
+    return str.slice(0, maxLen - 3) + "...";
+  }
+};
+function isTextCapture(capture) {
+  return "type" in capture && capture.type === "reasoning";
+}
+function isToolCapture(capture) {
+  return "tool" in capture;
+}
+function formatCaptureContent(capture) {
+  if (isTextCapture(capture)) {
+    return capture.content;
+  }
+  return formatToolMemoryContent(capture.tool, capture.input, capture.output);
+}
+function formatToolMemoryContent(tool, input, output) {
+  const maxOutputLen = 200;
+  switch (tool) {
+    case "Edit": {
+      const filePath = input.file_path || "unknown file";
+      const oldStr = input.old_string || "";
+      const newStr = input.new_string || "";
+      let description = "";
+      if (!oldStr && newStr) {
+        description = "Added new content";
+      } else if (oldStr && !newStr) {
+        description = "Removed content";
+      } else {
+        description = "Modified content";
+      }
+      return `[Edit] ${filePath}
+${description}. ${truncate(output, maxOutputLen)}`;
+    }
+    case "Write": {
+      const filePath = input.file_path || "unknown file";
+      const content = input.content || "";
+      const preview = content.slice(0, 100);
+      return `[Write] ${filePath}
+Created new file. Preview: ${truncate(preview, maxOutputLen)}`;
+    }
+    case "Bash": {
+      const command = input.command || "unknown command";
+      return `[Bash] ${truncate(command, 100)}
+Output: ${truncate(output, maxOutputLen)}`;
+    }
+    case "Task": {
+      const description = input.description || "Agent task";
+      const prompt = input.prompt || "";
+      return `[Task] ${description}
+${truncate(prompt, 100)}
+Result: ${truncate(output, 300)}`;
+    }
+    default:
+      return `[${tool}] ${truncate(output, maxOutputLen)}`;
+  }
+}
+function truncate(str, maxLen) {
+  if (str.length <= maxLen)
+    return str;
+  return str.slice(0, maxLen - 3) + "...";
+}
+
+// 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/stop.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("Stop", "Hook fired", {
+    session_id: input.session_id,
+    cwd: input.cwd,
+    has_transcript: !!input.transcript_path
+  });
+  try {
+    if (!(0, import_fs3.existsSync)(DB_PATH)) {
+      log("Stop", "DB not found, skipping");
+      outputResult({ continue: true, suppressOutput: true });
+      return;
+    }
+    if (!input.transcript_path || !(0, import_fs3.existsSync)(input.transcript_path)) {
+      log("Stop", "No transcript path, skipping");
+      outputResult({ continue: true, suppressOutput: true });
+      return;
+    }
+    const config = await loadConfig();
+    const transcriptContent = await (0, import_promises3.readFile)(input.transcript_path, "utf-8");
+    const parser = new TranscriptParser({
+      toolConfig: config.capture?.tools ?? {},
+      maxReasoningLength: config.capture?.maxReasoningLength ?? 1e4,
+      maxToolOutputLength: config.capture?.maxToolOutputLength ?? 2e3,
+      captureReasoning: config.capture?.captureReasoning ?? true
+    });
+    const captures = parser.parse(transcriptContent);
+    if (captures.length === 0) {
+      log("Stop", "No captures found");
+      outputResult({ continue: true, suppressOutput: true });
+      return;
+    }
+    const reasoningCount = captures.filter(isTextCapture).length;
+    const toolCount = captures.filter(isToolCapture).length;
+    log("Stop", `Found ${captures.length} captures to save`, { reasoning: reasoningCount, tools: toolCount });
+    const projectId = getProjectId2(input.cwd);
+    const sqlite = new SQLiteStorage(DB_PATH);
+    const lancedb2 = await LanceDBStorage.create(VECTORS_PATH);
+    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 embedder = await createEmbedFunction(MODELS_PATH);
+    for (const capture of captures) {
+      const content = formatCaptureContent(capture);
+      const memoryId = (0, import_crypto.randomUUID)();
+      let memory;
+      if (isTextCapture(capture)) {
+        memory = {
+          id: memoryId,
+          projectId,
+          content,
+          type: "reasoning",
+          sourceTool: null,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          sessionId: input.session_id,
+          metadata: null
+        };
+      } else {
+        memory = {
+          id: memoryId,
+          projectId,
+          content,
+          type: "tool_capture",
+          sourceTool: capture.tool,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          sessionId: input.session_id,
+          metadata: {
+            input: capture.input,
+            outputPreview: capture.output.slice(0, 200)
+          }
+        };
+      }
+      sqlite.insertMemory(memory);
+      const vector = await embedder.embed(content);
+      await lancedb2.insertVector(memoryId, vector);
+    }
+    const dedupeOnPrune = config.storage?.deduplicateOnPrune ?? true;
+    const dedupeThreshold = config.retrieval?.deduplicationThreshold ?? 0.85;
+    if (dedupeOnPrune) {
+      const dedupedIds = await deduplicateStoredMemories(
+        sqlite,
+        lancedb2,
+        projectId,
+        dedupeThreshold
+      );
+      if (dedupedIds.length > 0) {
+        log("Stop", `Deduplicated ${dedupedIds.length} similar memories`);
+      }
+    }
+    const maxPerProject = config.storage?.maxMemoriesPerProject ?? 500;
+    const maxTotal = config.storage?.maxTotalMemories ?? 5e3;
+    if (maxPerProject > 0 || maxTotal > 0) {
+      const pruneResult = sqlite.pruneMemories({
+        maxPerProject,
+        maxTotal,
+        projectId
+      });
+      if (pruneResult.deleted > 0) {
+        log("Stop", `Pruned ${pruneResult.deleted} old memories to stay within limits`);
+        for (const id of pruneResult.deletedIds) {
+          await lancedb2.deleteVector(id);
+        }
+      }
+    }
+    sqlite.close();
+    await lancedb2.close();
+    await embedder.close();
+    log("Stop", `SUCCESS: Saved ${captures.length} memories`);
+    outputResult({ continue: true, suppressOutput: true });
+  } catch (error) {
+    logError("Stop", error);
+    console.error("[memextend] Stop hook error:", error);
+    outputResult({ continue: true, suppressOutput: true });
+  }
+}
+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));
+}
+async function deduplicateStoredMemories(sqlite, lancedb2, projectId, threshold) {
+  const deletedIds = [];
+  const memories = sqlite.getRecentMemories(projectId, 0, 0);
+  if (memories.length < 2)
+    return deletedIds;
+  const memoryIds = memories.map((m) => m.id);
+  const vectors = await lancedb2.getVectorsByIds(memoryIds);
+  if (vectors.size < 2)
+    return deletedIds;
+  const keepIds = /* @__PURE__ */ new Set();
+  const keptVectors = [];
+  for (const memory of memories) {
+    const vector = vectors.get(memory.id);
+    if (!vector) {
+      keepIds.add(memory.id);
+      continue;
+    }
+    let isDuplicate = false;
+    for (const kept of keptVectors) {
+      const similarity = cosineSimilarity(vector, kept.vector);
+      if (similarity > threshold) {
+        isDuplicate = true;
+        break;
+      }
+    }
+    if (!isDuplicate) {
+      keepIds.add(memory.id);
+      keptVectors.push({ id: memory.id, vector });
+    } else {
+      sqlite.deleteMemory(memory.id);
+      await lancedb2.deleteVector(memory.id);
+      deletedIds.push(memory.id);
+    }
+  }
+  return deletedIds;
+}
+main().catch((error) => {
+  console.error("[memextend] Fatal error:", error);
+  process.exit(0);
+});