fossel 1.0.1 → 1.0.8

package/dist/index.js

@@ -2,7 +2,8 @@
 
 // src/index.ts
 import { homedir } from "os";
-import { join } from "path";
+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";
 
@@ -10,6 +11,106 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import Database from "better-sqlite3";
 import { mkdirSync } from "fs";
 import { dirname } from "path";
+
+// 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);
+}
+var 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;
+        `);
+      }
+    }
+  }
+];
+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();
+  }
+}
+
+// src/db/client.ts
 var MEMORY_TYPES = [
   "convention",
   "bug_fix",
@@ -19,40 +120,6 @@ var MEMORY_TYPES = [
   "general"
 ];
 var dbInstance = null;
-var SCHEMA_SQL = `
-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,
-  updated_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;
-`;
 function initDb(dbPath) {
   if (dbInstance) {
     return dbInstance;
@@ -61,7 +128,7 @@ function initDb(dbPath) {
   const db = new Database(dbPath);
   db.pragma("journal_mode = WAL");
   db.pragma("foreign_keys = ON");
-  db.exec(SCHEMA_SQL);
+  runMigrations(db);
   dbInstance = db;
   return db;
 }
@@ -156,10 +223,10 @@ function registerGetRepoContextTool(server) {
         const db = getDb();
         const rows = db.prepare(
           `
-              SELECT id, repo, type, note, tags, created_at, updated_at
+              SELECT rowid AS row_id, id, repo, type, note, tags, created_at, updated_at, pinned
               FROM memories
               WHERE repo = ?
-              ORDER BY updated_at DESC
+              ORDER BY pinned DESC, updated_at DESC
               LIMIT ?
             `
         ).all(repo, limit);
@@ -177,7 +244,8 @@ function registerGetRepoContextTool(server) {
         for (const memory of rows) {
           const tags = parseTags(memory.tags);
           const tagSuffix = tags.length > 0 ? ` [tags: ${tags.join(", ")}]` : "";
-          const item = `- (${memory.id}) ${memory.note}${tagSuffix}`;
+          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);
@@ -218,12 +286,127 @@ ${sections.join("\n\n")}`
   );
 }
 
-// src/tools/search.ts
+// src/tools/pin.ts
 import { z as z3 } from "zod";
+var pinInputSchema = {
+  id: z3.number().int().positive()
+};
+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}`
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/search.ts
+import { z as z4 } from "zod";
 var searchMemoryInputSchema = {
-  query: z3.string().trim().min(1, "query is required"),
-  repo: z3.string().trim().min(1).optional(),
-  limit: z3.number().int().positive().max(50).default(5)
+  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)
 };
 function normalizeFtsQuery(query) {
   const terms = query.trim().split(/\s+/).map((term) => term.replaceAll('"', '""')).filter(Boolean);
@@ -253,7 +436,7 @@ function registerSearchMemoryTool(server) {
         const ftsQuery = normalizeFtsQuery(query);
         const rows = repo ? db.prepare(
           `
-                  SELECT m.id, m.repo, m.type, m.note, m.tags, m.created_at, m.updated_at, bm25(memories_fts) AS rank
+                  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 = ?
@@ -262,7 +445,7 @@ function registerSearchMemoryTool(server) {
                 `
         ).all(ftsQuery, repo, limit) : db.prepare(
           `
-                  SELECT m.id, m.repo, m.type, m.note, m.tags, m.created_at, m.updated_at, bm25(memories_fts) AS rank
+                  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 ?
@@ -283,8 +466,9 @@ function registerSearchMemoryTool(server) {
         const formatted = rows.map((row, index) => {
           const tags = parseTags2(row.tags);
           const tagsText = tags.length > 0 ? ` | tags: ${tags.join(", ")}` : "";
-          return `${index + 1}. [${row.repo}] ${row.type} (${row.id})
-${row.note}${tagsText}`;
+          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: [
@@ -314,12 +498,12 @@ ${formatted}`
 
 // src/tools/store.ts
 import { nanoid } from "nanoid";
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 var storeContextInputSchema = {
-  repo: z4.string().trim().min(1, "repo is required"),
-  type: z4.enum(MEMORY_TYPES),
-  note: z4.string().trim().min(1, "note is required"),
-  tags: z4.array(z4.string().trim().min(1)).optional()
+  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()
 };
 function registerStoreContextTool(server) {
   server.registerTool(
@@ -342,11 +526,18 @@ function registerStoreContextTool(server) {
             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} for ${repo} (${type}).`
+              text: `Stored memory ${id} (numeric id: ${stored?.row_id ?? "unknown"}) for ${repo} (${type}).`
             }
           ]
         };
@@ -366,9 +557,215 @@ function registerStoreContextTool(server) {
   );
 }
 
+// src/tools/summarize.ts
+import { z as z6 } from "zod";
+var summarizeRepoContextInputSchema = {
+  repo: z6.string().trim().min(1, "repo is required")
+};
+var sectionTitleByType = {
+  convention: "Conventions",
+  bug_fix: "Bug Fixes",
+  reviewer_pattern: "Reviewer Patterns",
+  decision: "Decisions",
+  issue: "Issues",
+  general: "General"
+};
+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}`
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/update.ts
+import { z as z7 } from "zod";
+var updateMemoryInputSchema = {
+  id: z7.number().int().positive(),
+  content: z7.string().trim().min(1).optional(),
+  memory_type: z7.enum(MEMORY_TYPES).optional()
+};
+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}`
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+
 // src/index.ts
-async function main() {
-  const dbPath = process.env.FOSSYL_DB_PATH?.trim() || join(homedir(), ".fossyl", "memory.db");
+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",
@@ -378,11 +775,23 @@ async function main() {
   registerGetRepoContextTool(server);
   registerSearchMemoryTool(server);
   registerDeleteMemoryTool(server);
+  registerUpdateMemoryTool(server);
+  registerPinMemoryTool(server);
+  registerUnpinMemoryTool(server);
+  registerSummarizeRepoContextTool(server);
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }
-main().catch((error) => {
-  const message = error instanceof Error ? error.message : String(error);
-  console.error(`Fossyl server failed to start: ${message}`);
-  process.exit(1);
-});
+var entryPath = process.argv[1];
+var 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);
+  });
+}
+export {
+  resolveDbPath,
+  startServer
+};

package/package.json

@@ -1,19 +1,21 @@
 {
   "name": "fossel",
-  "version": "1.0.1",
+  "version": "1.0.8",
   "description": "Local MCP memory server for open-source contributors",
   "type": "module",
   "files": [
     "dist"
   ],
   "bin": {
-    "fossel": "dist/index.js"
+    "fossel": "dist/cli.js"
   },
   "scripts": {
     "build": "tsup",
     "dev": "tsx src/index.ts",
     "start": "node dist/index.js",
-    "smoke": "tsx scripts/smoke.ts"
+    "smoke": "tsx scripts/smoke.ts",
+    "typecheck": "tsc --noEmit",
+    "ci": "npm run typecheck && npm run build && npm run smoke"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "latest",