fossel 1.0.1 → 1.0.8

package/dist/cli.js

@@ -0,0 +1,1020 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/db/migrate.ts
+function hasColumn(db, tableName, columnName) {
+  const columns = db.prepare(`PRAGMA table_info(${tableName})`).all();
+  return columns.some((column) => column.name === columnName);
+}
+function runMigrations(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS migrations (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL UNIQUE,
+      applied_at INTEGER NOT NULL
+    );
+  `);
+  const appliedRows = db.prepare("SELECT name FROM migrations").all();
+  const applied = new Set(appliedRows.map((row) => row.name));
+  const insertMigration = db.prepare(`
+    INSERT INTO migrations (name, applied_at)
+    VALUES (?, ?)
+  `);
+  for (const migration of migrations) {
+    if (applied.has(migration.name)) {
+      continue;
+    }
+    const applyTx = db.transaction(() => {
+      migration.apply(db);
+      insertMigration.run(migration.name, Math.floor(Date.now() / 1e3));
+    });
+    applyTx();
+  }
+}
+var migrations;
+var init_migrate = __esm({
+  "src/db/migrate.ts"() {
+    "use strict";
+    migrations = [
+      {
+        name: "001_init_memories_schema",
+        apply: (db) => {
+          db.exec(`
+        CREATE TABLE IF NOT EXISTS memories (
+          id TEXT PRIMARY KEY,
+          repo TEXT NOT NULL,
+          type TEXT NOT NULL CHECK (type IN ('convention', 'bug_fix', 'reviewer_pattern', 'decision', 'issue', 'general')),
+          note TEXT NOT NULL,
+          tags TEXT NOT NULL DEFAULT '[]',
+          created_at INTEGER NOT NULL
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_memories_repo ON memories (repo);
+        CREATE INDEX IF NOT EXISTS idx_memories_created_at ON memories (created_at DESC);
+
+        CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+          repo,
+          note,
+          content = 'memories',
+          content_rowid = 'rowid'
+        );
+
+        CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
+          INSERT INTO memories_fts(rowid, repo, note) VALUES (new.rowid, new.repo, new.note);
+        END;
+
+        CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
+          INSERT INTO memories_fts(memories_fts, rowid, repo, note) VALUES ('delete', old.rowid, old.repo, old.note);
+        END;
+
+        CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
+          INSERT INTO memories_fts(memories_fts, rowid, repo, note) VALUES ('delete', old.rowid, old.repo, old.note);
+          INSERT INTO memories_fts(rowid, repo, note) VALUES (new.rowid, new.repo, new.note);
+        END;
+      `);
+        }
+      },
+      {
+        name: "002_add_memories_updated_at",
+        apply: (db) => {
+          if (!hasColumn(db, "memories", "updated_at")) {
+            db.exec(`
+          ALTER TABLE memories
+          ADD COLUMN updated_at INTEGER NOT NULL DEFAULT 0;
+        `);
+            db.exec(`
+          UPDATE memories
+          SET updated_at = created_at
+          WHERE updated_at = 0;
+        `);
+          }
+        }
+      },
+      {
+        name: "003_add_memories_pinned",
+        apply: (db) => {
+          if (!hasColumn(db, "memories", "pinned")) {
+            db.exec(`
+          ALTER TABLE memories
+          ADD COLUMN pinned INTEGER NOT NULL DEFAULT 0;
+        `);
+          }
+        }
+      }
+    ];
+  }
+});
+
+// src/db/client.ts
+import Database from "better-sqlite3";
+import { mkdirSync } from "fs";
+import { dirname } from "path";
+function initDb(dbPath) {
+  if (dbInstance) {
+    return dbInstance;
+  }
+  mkdirSync(dirname(dbPath), { recursive: true });
+  const db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  runMigrations(db);
+  dbInstance = db;
+  return db;
+}
+function getDb() {
+  if (!dbInstance) {
+    throw new Error("Database has not been initialized. Call initDb() first.");
+  }
+  return dbInstance;
+}
+function closeDb() {
+  if (!dbInstance) {
+    return;
+  }
+  dbInstance.close();
+  dbInstance = null;
+}
+var MEMORY_TYPES, dbInstance;
+var init_client = __esm({
+  "src/db/client.ts"() {
+    "use strict";
+    init_migrate();
+    MEMORY_TYPES = [
+      "convention",
+      "bug_fix",
+      "reviewer_pattern",
+      "decision",
+      "issue",
+      "general"
+    ];
+    dbInstance = null;
+  }
+});
+
+// src/tools/delete.ts
+import { z } from "zod";
+function registerDeleteMemoryTool(server) {
+  server.registerTool(
+    "delete_memory",
+    {
+      description: "Delete a memory from storage by id.",
+      inputSchema: deleteMemoryInputSchema
+    },
+    async ({ id }) => {
+      try {
+        const db = getDb();
+        const row = db.prepare("SELECT id FROM memories WHERE id = ?").get(id);
+        if (!row) {
+          return {
+            isError: true,
+            content: [
+              {
+                type: "text",
+                text: `Memory ${id} not found.`
+              }
+            ]
+          };
+        }
+        const deleteTx = db.transaction((memoryId) => {
+          db.prepare("DELETE FROM memories WHERE id = ?").run(memoryId);
+        });
+        deleteTx(id);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Deleted memory ${id}.`
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error while deleting memory.";
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Failed to delete memory: ${message}`
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+var deleteMemoryInputSchema;
+var init_delete = __esm({
+  "src/tools/delete.ts"() {
+    "use strict";
+    init_client();
+    deleteMemoryInputSchema = {
+      id: z.string().trim().min(1, "id is required")
+    };
+  }
+});
+
+// src/tools/get-repo.ts
+import { z as z2 } from "zod";
+function parseTags(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed.filter((value) => typeof value === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function formatTypeHeading(type) {
+  return type.split("_").map((part) => part[0]?.toUpperCase() + part.slice(1)).join(" ");
+}
+function registerGetRepoContextTool(server) {
+  server.registerTool(
+    "get_repo_context",
+    {
+      description: "Get recent memories for a repository grouped by memory type.",
+      inputSchema: getRepoContextInputSchema
+    },
+    async ({ repo, limit }) => {
+      try {
+        const db = getDb();
+        const rows = db.prepare(
+          `
+              SELECT rowid AS row_id, id, repo, type, note, tags, created_at, updated_at, pinned
+              FROM memories
+              WHERE repo = ?
+              ORDER BY pinned DESC, updated_at DESC
+              LIMIT ?
+            `
+        ).all(repo, limit);
+        if (rows.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `No memories found for ${repo}.`
+              }
+            ]
+          };
+        }
+        const grouped = /* @__PURE__ */ new Map();
+        for (const memory of rows) {
+          const tags = parseTags(memory.tags);
+          const tagSuffix = tags.length > 0 ? ` [tags: ${tags.join(", ")}]` : "";
+          const pinPrefix = memory.pinned ? "\u{1F4CC} Pinned " : "";
+          const item = `- (${memory.row_id} | legacy: ${memory.id}) ${pinPrefix}${memory.note}${tagSuffix}`;
+          const existing = grouped.get(memory.type) ?? [];
+          existing.push(item);
+          grouped.set(memory.type, existing);
+        }
+        const sections = [];
+        for (const type of MEMORY_TYPES) {
+          const entries = grouped.get(type);
+          if (!entries || entries.length === 0) {
+            continue;
+          }
+          sections.push(`${formatTypeHeading(type)}
+${entries.join("\n")}`);
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Repository context for ${repo}
+Total memories: ${rows.length}
+
+${sections.join("\n\n")}`
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error while retrieving repository context.";
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Failed to fetch repository context: ${message}`
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+var getRepoContextInputSchema;
+var init_get_repo = __esm({
+  "src/tools/get-repo.ts"() {
+    "use strict";
+    init_client();
+    getRepoContextInputSchema = {
+      repo: z2.string().trim().min(1, "repo is required"),
+      limit: z2.number().int().positive().max(100).default(10)
+    };
+  }
+});
+
+// src/tools/pin.ts
+import { z as z3 } from "zod";
+function setPinnedState(memoryId, pinned) {
+  const db = getDb();
+  const now = Math.floor(Date.now() / 1e3);
+  const updateResult = db.prepare(
+    `
+        UPDATE memories
+        SET pinned = ?, updated_at = ?
+        WHERE rowid = ?
+      `
+  ).run(pinned, now, memoryId);
+  if (updateResult.changes === 0) {
+    return null;
+  }
+  return db.prepare(
+    `
+        SELECT rowid AS row_id, note, pinned
+        FROM memories
+        WHERE rowid = ?
+      `
+  ).get(memoryId);
+}
+function registerPinMemoryTool(server) {
+  server.registerTool(
+    "pin_memory",
+    {
+      description: "Pin a memory to keep it at the top of repository context.",
+      inputSchema: pinInputSchema
+    },
+    async ({ id }) => {
+      try {
+        const memory = setPinnedState(id, 1);
+        if (!memory) {
+          return {
+            isError: true,
+            content: [
+              {
+                type: "text",
+                text: `Memory ${id} not found.`
+              }
+            ]
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Pinned memory ${memory.row_id}: ${memory.note}`
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error while pinning memory.";
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Failed to pin memory: ${message}`
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+function registerUnpinMemoryTool(server) {
+  server.registerTool(
+    "unpin_memory",
+    {
+      description: "Unpin a previously pinned memory.",
+      inputSchema: pinInputSchema
+    },
+    async ({ id }) => {
+      try {
+        const memory = setPinnedState(id, 0);
+        if (!memory) {
+          return {
+            isError: true,
+            content: [
+              {
+                type: "text",
+                text: `Memory ${id} not found.`
+              }
+            ]
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Unpinned memory ${memory.row_id}.`
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error while unpinning memory.";
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Failed to unpin memory: ${message}`
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+var pinInputSchema;
+var init_pin = __esm({
+  "src/tools/pin.ts"() {
+    "use strict";
+    init_client();
+    pinInputSchema = {
+      id: z3.number().int().positive()
+    };
+  }
+});
+
+// src/tools/search.ts
+import { z as z4 } from "zod";
+function normalizeFtsQuery(query) {
+  const terms = query.trim().split(/\s+/).map((term) => term.replaceAll('"', '""')).filter(Boolean);
+  if (terms.length === 0) {
+    throw new Error("query must contain searchable text");
+  }
+  return terms.map((term) => `"${term}"`).join(" AND ");
+}
+function parseTags2(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed.filter((value) => typeof value === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function registerSearchMemoryTool(server) {
+  server.registerTool(
+    "search_memory",
+    {
+      description: "Search memories using full-text search with optional repository filtering.",
+      inputSchema: searchMemoryInputSchema
+    },
+    async ({ query, repo, limit }) => {
+      try {
+        const db = getDb();
+        const ftsQuery = normalizeFtsQuery(query);
+        const rows = repo ? db.prepare(
+          `
+                  SELECT m.rowid AS row_id, m.id, m.repo, m.type, m.note, m.tags, m.created_at, m.updated_at, m.pinned, bm25(memories_fts) AS rank
+                  FROM memories_fts
+                  JOIN memories AS m ON m.rowid = memories_fts.rowid
+                  WHERE memories_fts MATCH ? AND m.repo = ?
+                  ORDER BY rank
+                  LIMIT ?
+                `
+        ).all(ftsQuery, repo, limit) : db.prepare(
+          `
+                  SELECT m.rowid AS row_id, m.id, m.repo, m.type, m.note, m.tags, m.created_at, m.updated_at, m.pinned, bm25(memories_fts) AS rank
+                  FROM memories_fts
+                  JOIN memories AS m ON m.rowid = memories_fts.rowid
+                  WHERE memories_fts MATCH ?
+                  ORDER BY rank
+                  LIMIT ?
+                `
+        ).all(ftsQuery, limit);
+        if (rows.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: repo ? `No memories matched "${query}" in ${repo}.` : `No memories matched "${query}".`
+              }
+            ]
+          };
+        }
+        const formatted = rows.map((row, index) => {
+          const tags = parseTags2(row.tags);
+          const tagsText = tags.length > 0 ? ` | tags: ${tags.join(", ")}` : "";
+          const pinPrefix = row.pinned ? "\u{1F4CC} Pinned " : "";
+          return `${index + 1}. [${row.repo}] ${row.type} (${row.row_id} | legacy: ${row.id})
+${pinPrefix}${row.note}${tagsText}`;
+        }).join("\n\n");
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Search results for "${query}"${repo ? ` in ${repo}` : ""}:
+
+${formatted}`
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error while searching memory.";
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Failed to search memories: ${message}`
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+var searchMemoryInputSchema;
+var init_search = __esm({
+  "src/tools/search.ts"() {
+    "use strict";
+    init_client();
+    searchMemoryInputSchema = {
+      query: z4.string().trim().min(1, "query is required"),
+      repo: z4.string().trim().min(1).optional(),
+      limit: z4.number().int().positive().max(50).default(5)
+    };
+  }
+});
+
+// src/tools/store.ts
+import { nanoid } from "nanoid";
+import { z as z5 } from "zod";
+function registerStoreContextTool(server) {
+  server.registerTool(
+    "store_context",
+    {
+      description: "Store repository-specific contributor context such as bug fixes, conventions, and decisions.",
+      inputSchema: storeContextInputSchema
+    },
+    async ({ repo, type, note, tags }) => {
+      try {
+        const db = getDb();
+        const now = Math.floor(Date.now() / 1e3);
+        const id = nanoid();
+        const normalizedTags = Array.from(
+          new Set((tags ?? []).map((tag) => tag.trim()).filter(Boolean))
+        );
+        db.prepare(
+          `
+            INSERT INTO memories (id, repo, type, note, tags, created_at, updated_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+          `
+        ).run(id, repo, type, note, JSON.stringify(normalizedTags), now, now);
+        const stored = db.prepare(
+          `
+              SELECT rowid AS row_id, id
+              FROM memories
+              WHERE id = ?
+            `
+        ).get(id);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Stored memory ${id} (numeric id: ${stored?.row_id ?? "unknown"}) for ${repo} (${type}).`
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error while storing memory.";
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Failed to store memory: ${message}`
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+var storeContextInputSchema;
+var init_store = __esm({
+  "src/tools/store.ts"() {
+    "use strict";
+    init_client();
+    storeContextInputSchema = {
+      repo: z5.string().trim().min(1, "repo is required"),
+      type: z5.enum(MEMORY_TYPES),
+      note: z5.string().trim().min(1, "note is required"),
+      tags: z5.array(z5.string().trim().min(1)).optional()
+    };
+  }
+});
+
+// src/tools/summarize.ts
+import { z as z6 } from "zod";
+function registerSummarizeRepoContextTool(server) {
+  server.registerTool(
+    "summarize_repo_context",
+    {
+      description: "Generate a structured markdown summary of all memories for a repository.",
+      inputSchema: summarizeRepoContextInputSchema
+    },
+    async ({ repo }) => {
+      try {
+        const db = getDb();
+        const rows = db.prepare(
+          `
+              SELECT rowid AS row_id, type, note, pinned
+              FROM memories
+              WHERE repo = ?
+              ORDER BY pinned DESC, updated_at DESC
+            `
+        ).all(repo);
+        if (rows.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Fossel Context Summary: ${repo}
+
+No memories found.`
+              }
+            ]
+          };
+        }
+        const pinnedLines = rows.filter((row) => row.pinned === 1).map((row) => `- (${row.row_id}) ${row.note}`);
+        const sections = [`Fossel Context Summary: ${repo}`];
+        if (pinnedLines.length > 0) {
+          sections.push(`\u{1F4CC} Pinned
+${pinnedLines.join("\n")}`);
+        }
+        for (const type of MEMORY_TYPES) {
+          const entries = rows.filter((row) => row.type === type).map((row) => `- (${row.row_id}) ${row.note}`);
+          if (entries.length === 0) {
+            continue;
+          }
+          sections.push(`${sectionTitleByType[type]}
+${entries.join("\n")}`);
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: sections.join("\n\n")
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error while summarizing repository context.";
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Failed to summarize repository context: ${message}`
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+var summarizeRepoContextInputSchema, sectionTitleByType;
+var init_summarize = __esm({
+  "src/tools/summarize.ts"() {
+    "use strict";
+    init_client();
+    summarizeRepoContextInputSchema = {
+      repo: z6.string().trim().min(1, "repo is required")
+    };
+    sectionTitleByType = {
+      convention: "Conventions",
+      bug_fix: "Bug Fixes",
+      reviewer_pattern: "Reviewer Patterns",
+      decision: "Decisions",
+      issue: "Issues",
+      general: "General"
+    };
+  }
+});
+
+// src/tools/update.ts
+import { z as z7 } from "zod";
+function parseTags3(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed.filter((value) => typeof value === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function formatMemory(memory) {
+  const tags = parseTags3(memory.tags);
+  const tagsLine = tags.length > 0 ? tags.join(", ") : "(none)";
+  return [
+    `Memory ${memory.row_id} updated successfully.`,
+    `id: ${memory.row_id}`,
+    `legacy_id: ${memory.id}`,
+    `repo: ${memory.repo}`,
+    `memory_type: ${memory.type}`,
+    `content: ${memory.note}`,
+    `tags: ${tagsLine}`,
+    `pinned: ${memory.pinned === 1 ? "true" : "false"}`,
+    `created_at: ${memory.created_at}`,
+    `updated_at: ${memory.updated_at}`
+  ].join("\n");
+}
+function registerUpdateMemoryTool(server) {
+  server.registerTool(
+    "update_memory",
+    {
+      description: "Update an existing memory by numeric id with partial fields.",
+      inputSchema: updateMemoryInputSchema
+    },
+    async ({ id, content, memory_type }) => {
+      try {
+        if (!content && !memory_type) {
+          return {
+            isError: true,
+            content: [
+              {
+                type: "text",
+                text: "Provide at least one field to update: content or memory_type."
+              }
+            ]
+          };
+        }
+        const db = getDb();
+        const existing = db.prepare(
+          `
+              SELECT rowid AS row_id, id, repo, type, note, tags, created_at, updated_at, pinned
+              FROM memories
+              WHERE rowid = ?
+            `
+        ).get(id);
+        if (!existing) {
+          return {
+            isError: true,
+            content: [
+              {
+                type: "text",
+                text: `Memory ${id} not found.`
+              }
+            ]
+          };
+        }
+        const now = Math.floor(Date.now() / 1e3);
+        const nextType = memory_type ?? existing.type;
+        const nextNote = content ?? existing.note;
+        db.prepare(
+          `
+            UPDATE memories
+            SET type = ?, note = ?, updated_at = ?
+            WHERE rowid = ?
+          `
+        ).run(nextType, nextNote, now, id);
+        const updated = db.prepare(
+          `
+              SELECT rowid AS row_id, id, repo, type, note, tags, created_at, updated_at, pinned
+              FROM memories
+              WHERE rowid = ?
+            `
+        ).get(id);
+        if (!updated) {
+          return {
+            isError: true,
+            content: [
+              {
+                type: "text",
+                text: `Memory ${id} could not be loaded after update.`
+              }
+            ]
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatMemory(updated)
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error while updating memory.";
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Failed to update memory: ${message}`
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+var updateMemoryInputSchema;
+var init_update = __esm({
+  "src/tools/update.ts"() {
+    "use strict";
+    init_client();
+    updateMemoryInputSchema = {
+      id: z7.number().int().positive(),
+      content: z7.string().trim().min(1).optional(),
+      memory_type: z7.enum(MEMORY_TYPES).optional()
+    };
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  resolveDbPath: () => resolveDbPath,
+  startServer: () => startServer
+});
+import { homedir } from "os";
+import { join, resolve } from "path";
+import { fileURLToPath } from "url";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+function resolveDbPath() {
+  return process.env.FOSSEL_DB_PATH?.trim() || join(homedir(), ".fossel", "memory.db");
+}
+async function startServer() {
+  const dbPath = resolveDbPath();
+  initDb(dbPath);
+  const server = new McpServer({
+    name: "fossel",
+    version: "1.0.0"
+  });
+  registerStoreContextTool(server);
+  registerGetRepoContextTool(server);
+  registerSearchMemoryTool(server);
+  registerDeleteMemoryTool(server);
+  registerUpdateMemoryTool(server);
+  registerPinMemoryTool(server);
+  registerUnpinMemoryTool(server);
+  registerSummarizeRepoContextTool(server);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+var entryPath, currentPath;
+var init_index = __esm({
+  "src/index.ts"() {
+    "use strict";
+    init_client();
+    init_delete();
+    init_get_repo();
+    init_pin();
+    init_search();
+    init_store();
+    init_summarize();
+    init_update();
+    entryPath = process.argv[1];
+    currentPath = fileURLToPath(import.meta.url);
+    if (entryPath && currentPath === resolve(entryPath)) {
+      startServer().catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Fossel server failed to start: ${message}`);
+        process.exit(1);
+      });
+    }
+  }
+});
+
+// src/cli.ts
+init_client();
+import { homedir as homedir2 } from "os";
+import { basename, join as join2 } from "path";
+import { spawnSync } from "child_process";
+import { nanoid as nanoid2 } from "nanoid";
+var DEFAULT_DB_PATH = join2(homedir2(), ".fossel", "memory.db");
+var INIT_MEMORY_TEXT = "Fossel is active for this repo. Use store_context to save context.";
+function resolveDbPath2() {
+  return process.env.FOSSEL_DB_PATH?.trim() || DEFAULT_DB_PATH;
+}
+function detectRepoFromRemote(cwd) {
+  const result = spawnSync("git", ["remote", "get-url", "origin"], {
+    cwd,
+    encoding: "utf8"
+  });
+  if (result.status !== 0) {
+    return null;
+  }
+  const remote = result.stdout.trim();
+  if (!remote) {
+    return null;
+  }
+  const normalized = remote.replace(/\\/g, "/").replace(/\/+$/, "");
+  const lastSegment = normalized.split("/").at(-1);
+  if (!lastSegment) {
+    return null;
+  }
+  return lastSegment.replace(/\.git$/i, "");
+}
+function detectRepoName(cwd) {
+  return detectRepoFromRemote(cwd) ?? basename(cwd);
+}
+function ensureSampleMemory(repo) {
+  const db = getDb();
+  const existing = db.prepare(
+    `
+        SELECT rowid AS row_id
+        FROM memories
+        WHERE repo = ? AND type = 'convention' AND note = ?
+        LIMIT 1
+      `
+  ).get(repo, INIT_MEMORY_TEXT);
+  if (existing) {
+    return;
+  }
+  const now = Math.floor(Date.now() / 1e3);
+  db.prepare(
+    `
+      INSERT INTO memories (id, repo, type, note, tags, created_at, updated_at, pinned)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `
+  ).run(nanoid2(), repo, "convention", INIT_MEMORY_TEXT, "[]", now, now, 0);
+}
+function formatCursorConfig() {
+  return JSON.stringify(
+    {
+      mcpServers: {
+        fossel: {
+          command: "npx",
+          args: ["-y", "fossel"]
+        }
+      }
+    },
+    null,
+    2
+  );
+}
+function formatClaudeDesktopConfig() {
+  return JSON.stringify(
+    {
+      mcpServers: {
+        fossel: {
+          command: "npx",
+          args: ["-y", "fossel"]
+        }
+      }
+    },
+    null,
+    2
+  );
+}
+function printInitOutput(repo, dbPath) {
+  const db = getDb();
+  const countRow = db.prepare("SELECT COUNT(*) AS count FROM memories").get();
+  console.log("Fossel remembers project context locally for each repository.");
+  console.log("Store conventions, fixes, and decisions once; retrieve them when needed.");
+  console.log("Everything stays in your local SQLite database.\n");
+  console.log(`Detected repository: ${repo}
+`);
+  console.log("Cursor MCP config (~/.cursor/mcp.json):");
+  console.log(formatCursorConfig());
+  console.log("");
+  console.log("Claude Desktop MCP config:");
+  console.log(formatClaudeDesktopConfig());
+  console.log("");
+  console.log(`DB Path: ${dbPath}`);
+  console.log(`Total memories: ${countRow.count}`);
+  console.log("");
+  console.log("Quick commands");
+  console.log("Command                  Description");
+  console.log("-----------------------  --------------------------------------------");
+  console.log("npx -y fossel            Start Fossel MCP server over stdio");
+  console.log("npx -y fossel init       Initialize Fossel for current repository");
+  console.log("store_context            Save context memory");
+  console.log("get_repo_context         Retrieve recent repo memories");
+  console.log("summarize_repo_context   Generate markdown context summary");
+}
+async function main() {
+  const command = process.argv[2];
+  if (!command) {
+    const { startServer: startServer2 } = await Promise.resolve().then(() => (init_index(), index_exports));
+    await startServer2();
+    return;
+  }
+  if (command === "init") {
+    const dbPath = resolveDbPath2();
+    initDb(dbPath);
+    const repo = detectRepoName(process.cwd());
+    ensureSampleMemory(repo);
+    printInitOutput(repo, dbPath);
+    closeDb();
+    return;
+  }
+  console.error(`Unknown command: ${command}`);
+  console.error("Usage: fossel [init]");
+  process.exit(1);
+}
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`Fossel command failed: ${message}`);
+  process.exit(1);
+});