session-collab-mcp 2.1.0 → 2.3.0

package/dist/{chunk-V4APNPXF.js → chunk-TFGXE3EI.js}

@@ -4,11 +4,28 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/db/migrations.ts
+import { readFileSync, readdirSync } from "fs";
+import { join } from "path";
+var VERSIONED_MIGRATION_PATTERN = /^\d{4}_.+\.sql$/;
+function listMigrationFiles(migrationsDir) {
+  return readdirSync(migrationsDir).filter((file) => VERSIONED_MIGRATION_PATTERN.test(file)).sort((left, right) => left.localeCompare(right, "en"));
+}
+function loadMigrationsFromDir(migrationsDir) {
+  return listMigrationFiles(migrationsDir).map(
+    (file) => readFileSync(join(migrationsDir, file), "utf-8")
+  );
+}
+function splitMigrationStatements(migration) {
+  const withoutCommentLines = migration.split("\n").filter((line) => !line.trim().startsWith("--")).join("\n");
+  return withoutCommentLines.split(";").map((statement) => statement.trim()).filter((statement) => statement.length > 0);
+}
+
 // src/db/sqlite-adapter.ts
 import Database from "better-sqlite3";
 import { randomUUID } from "crypto";
 import { existsSync, mkdirSync } from "fs";
-import { dirname, join } from "path";
+import { dirname, join as join2 } from "path";
 import { homedir } from "os";
 if (typeof globalThis.crypto === "undefined") {
   globalThis.crypto = {
@@ -93,7 +110,7 @@ var SqliteDatabase = class {
   // Handles upgrades gracefully by ignoring "already exists" and "duplicate column" errors
   initSchema(migrations) {
     for (const migration of migrations) {
-      const statements = migration.split(";").map((s) => s.trim()).filter((s) => s.length > 0 && !s.startsWith("--"));
+      const statements = splitMigrationStatements(migration);
       for (const stmt of statements) {
         try {
           this.runSql(stmt);
@@ -116,8 +133,8 @@ var SqliteDatabase = class {
   }
 };
 function getDefaultDbPath() {
-  const dataDir = join(homedir(), ".claude", "session-collab");
-  return join(dataDir, "collab.db");
+  const dataDir = join2(homedir(), ".claude", "session-collab");
+  return join2(dataDir, "collab.db");
 }
 function createLocalDatabase(dbPath) {
   const path = dbPath ?? getDefaultDbPath();
@@ -125,13 +142,13 @@ function createLocalDatabase(dbPath) {
 }
 
 // src/constants.ts
-import { readFileSync } from "fs";
-import { join as join2, dirname as dirname2 } from "path";
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join3, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
 function getVersion() {
   try {
     const __dirname2 = dirname2(fileURLToPath(import.meta.url));
-    const pkg = JSON.parse(readFileSync(join2(__dirname2, "..", "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync2(join3(__dirname2, "..", "package.json"), "utf-8"));
     return pkg.version;
   } catch {
     return "0.0.0";
@@ -144,12 +161,13 @@ var SERVER_INSTRUCTIONS = `
 
 Coordinate sessions and persist context across conversations.
 
-## 10 Core Tools
+## Core Tools
 
-### Session (5 tools)
+### Session
 - \`collab_session_start\`: Start session with project_root
 - \`collab_session_end\`: End session, release claims
-- \`collab_session_list\`: List active sessions
+- \`collab_session_list\`: List active sessions and their active claim summaries
+- \`collab_session_update\`: Update heartbeat, current task, todos, and progress
 - \`collab_config\`: Configure session behavior
 - \`collab_status\`: Get session status and summary
 
@@ -170,10 +188,11 @@ Coordinate sessions and persist context across conversations.
 
 1. **On start**: \`collab_session_start\` with project_root
 2. **Before editing**: \`collab_claim\` action="check"
-3. **For changes**: \`collab_claim\` action="create"
+3. **For changes**: \`collab_claim\` action="create" (blocked by default if another active session conflicts)
 4. **Save context**: \`collab_memory_save\` for important findings
-5. **When done**: \`collab_claim\` action="release"
-6. **On end**: \`collab_session_end\`
+5. **While working**: \`collab_session_update\` with current_task/todos
+6. **When done**: \`collab_claim\` action="release"
+7. **On end**: \`collab_session_end\`
 
 ## Memory Categories
 
@@ -4239,6 +4258,27 @@ var JsonRpcRequestSchema = external_exports.object({
   method: external_exports.string(),
   params: external_exports.record(external_exports.unknown()).optional()
 });
+var MCP_ERROR_CODES = {
+  PARSE_ERROR: -32700,
+  INVALID_REQUEST: -32600,
+  METHOD_NOT_FOUND: -32601,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603
+};
+function createSuccessResponse(id, result) {
+  return {
+    jsonrpc: "2.0",
+    id,
+    result
+  };
+}
+function createErrorResponse(id, code, message, data) {
+  return {
+    jsonrpc: "2.0",
+    id,
+    error: { code, message, data }
+  };
+}
 function createToolResult(text, isError = false) {
   return {
     content: [{ type: "text", text }],
@@ -4296,6 +4336,39 @@ async function listSessions(db, params = {}) {
   const result = await db.prepare(query).bind(...bindings).all();
   return result.results;
 }
+async function updateSessionHeartbeat(db, id, statusUpdate) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let progress = null;
+  let todosJson = null;
+  if (statusUpdate?.todos) {
+    const total = statusUpdate.todos.length;
+    const completed = statusUpdate.todos.filter((t) => t.status === "completed").length;
+    progress = {
+      completed,
+      total,
+      percentage: total > 0 ? Math.round(completed / total * 100) : 0
+    };
+    todosJson = JSON.stringify(statusUpdate.todos);
+  }
+  let query = "UPDATE sessions SET last_heartbeat = ?";
+  const bindings = [now];
+  if (statusUpdate?.current_task !== void 0) {
+    query += ", current_task = ?";
+    bindings.push(statusUpdate.current_task);
+  }
+  if (progress) {
+    query += ", progress = ?";
+    bindings.push(JSON.stringify(progress));
+  }
+  if (todosJson) {
+    query += ", todos = ?";
+    bindings.push(todosJson);
+  }
+  query += " WHERE id = ? AND status = 'active'";
+  bindings.push(id);
+  const result = await db.prepare(query).bind(...bindings).run();
+  return result.meta.changes > 0;
+}
 async function endSession(db, id, release_claims = "abandon") {
   const claimStatus = release_claims === "complete" ? "completed" : "abandoned";
   await db.prepare("UPDATE claims SET status = ?, updated_at = ? WHERE session_id = ? AND status = 'active'").bind(claimStatus, (/* @__PURE__ */ new Date()).toISOString(), id).run();
@@ -4960,7 +5033,8 @@ var claimCreateSchema = external_exports.object({
   symbols: symbolClaimsArraySchema.optional(),
   intent: external_exports.string().min(1, "intent is required"),
   scope: claimScopeSchema.optional(),
-  priority: external_exports.number().min(0).max(100).optional()
+  priority: external_exports.number().min(0).max(100).optional(),
+  allow_conflicts: external_exports.boolean().optional()
 }).refine(
   (data) => data.files && data.files.length > 0 || data.symbols && data.symbols.length > 0,
   { message: "Either files or symbols must be provided" }
@@ -4974,7 +5048,7 @@ var claimUpdatePrioritySchema = external_exports.object({
 var claimCheckSchema = external_exports.object({
   files: filesArraySchema,
   symbols: symbolClaimsArraySchema.optional(),
-  session_id: external_exports.string().optional(),
+  session_id: sessionIdSchema,
   exclude_self: external_exports.boolean().optional()
 });
 var claimReleaseSchema = external_exports.object({
@@ -5066,6 +5140,14 @@ function validationError(message) {
 }
 
 // src/mcp/tools/session.ts
+function parseJsonField(value) {
+  if (!value) return null;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
 var sessionTools = [
   {
     name: "collab_session_start",
@@ -5121,6 +5203,39 @@ var sessionTools = [
       }
     }
   },
+  {
+    name: "collab_session_update",
+    description: "Update session heartbeat, current task, todos, and progress.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        session_id: {
+          type: "string",
+          description: "Session ID to update"
+        },
+        current_task: {
+          type: "string",
+          description: "Current work summary"
+        },
+        todos: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              content: { type: "string" },
+              status: {
+                type: "string",
+                enum: ["pending", "in_progress", "completed"]
+              }
+            },
+            required: ["content", "status"]
+          },
+          description: "Current todo state for progress reporting"
+        }
+      },
+      required: ["session_id"]
+    }
+  },
   {
     name: "collab_config",
     description: "Configure session behavior.",
@@ -5270,7 +5385,17 @@ Decisions:
             id: session.id,
             name: session.name,
             status: session.status,
+            current_task: session.current_task,
+            progress: parseJsonField(session.progress),
+            todos: parseJsonField(session.todos),
             active_claims: claims.length,
+            claims: claims.map((c) => ({
+              id: c.id,
+              files: c.files,
+              intent: c.intent,
+              priority: getPriorityLevel(c.priority),
+              created_at: c.created_at
+            })),
             last_heartbeat: session.last_heartbeat
           };
         })
@@ -5280,6 +5405,34 @@ Decisions:
         total: sessionsWithClaims.length
       });
     }
+    case "collab_session_update": {
+      const validation = validateInput(statusUpdateSchema, args);
+      if (!validation.success) {
+        return validationError(validation.error);
+      }
+      const input = validation.data;
+      const sessionResult = await validateActiveSession(db, input.session_id);
+      if (!sessionResult.valid) {
+        return sessionResult.error;
+      }
+      const updated = await updateSessionHeartbeat(db, input.session_id, {
+        current_task: input.current_task,
+        todos: input.todos
+      });
+      if (!updated) {
+        return errorResponse(ERROR_CODES.SESSION_NOT_FOUND, "Session not found");
+      }
+      const session = await getSession(db, input.session_id);
+      return successResponse({
+        success: true,
+        session_id: input.session_id,
+        current_task: session?.current_task ?? null,
+        progress: parseJsonField(session?.progress ?? null),
+        todos: parseJsonField(session?.todos ?? null),
+        last_heartbeat: session?.last_heartbeat ?? null,
+        message: "Session updated."
+      });
+    }
     case "collab_config": {
       const validation = validateInput(configSchema, args);
       if (!validation.success) {
@@ -5419,6 +5572,10 @@ var claimTools = [
           type: "boolean",
           description: "Force release even if not owner (for release action)"
         },
+        allow_conflicts: {
+          type: "boolean",
+          description: "Explicitly create a claim even when conflicts are detected (for create action)"
+        },
         summary: {
           type: "string",
           description: "Release summary (for release action)"
@@ -5454,6 +5611,21 @@ async function handleClaimTool(db, name, args) {
       }
       const symbolFiles = (input.symbols ?? []).map((symbol) => symbol.file);
       const files = Array.from(/* @__PURE__ */ new Set([...input.files ?? [], ...symbolFiles]));
+      const conflicts = await checkConflicts(db, files, input.session_id, input.symbols);
+      if (conflicts.length > 0 && !input.allow_conflicts) {
+        return successResponse({
+          success: false,
+          status: "blocked_by_conflicts",
+          files,
+          symbols: input.symbols ?? [],
+          conflicts: conflicts.map((c) => ({
+            session_name: c.session_name,
+            file: c.file_path,
+            intent: c.intent
+          })),
+          message: `Claim not created. ${conflicts.length} conflict(s) detected. Coordinate before proceeding.`
+        });
+      }
       const { claim } = await createClaim(db, {
         session_id: input.session_id,
         files,
@@ -5478,7 +5650,6 @@ Files: ${files.join(", ")}`,
         related_claim_id: claim.id,
         metadata: { claim_id: claim.id, files }
       });
-      const conflicts = await checkConflicts(db, files, input.session_id, input.symbols);
       if (conflicts.length > 0) {
         return successResponse({
           success: true,
@@ -5958,7 +6129,76 @@ async function handleProtectionTool(db, name, args) {
 }
 
 // src/mcp/server.ts
+var SERVER_INFO = {
+  name: SERVER_NAME,
+  version: VERSION
+};
+var CAPABILITIES = {
+  tools: {}
+};
 var ALL_TOOLS = [...sessionTools, ...claimTools, ...memoryTools, ...protectionTools];
+var McpServer = class {
+  constructor(db, authContext) {
+    this.db = db;
+    this.authContext = authContext;
+  }
+  authContext;
+  async handleRequest(request) {
+    const { method, params, id } = request;
+    try {
+      switch (method) {
+        case "initialize":
+          return await this.handleInitialize(id);
+        case "notifications/initialized":
+          return createSuccessResponse(id, {});
+        case "tools/list":
+          return await this.handleToolsList(id);
+        case "tools/call":
+          return await this.handleToolCall(id, params);
+        case "ping":
+          return createSuccessResponse(id, {});
+        default:
+          return createErrorResponse(id, MCP_ERROR_CODES.METHOD_NOT_FOUND, `Method not found: ${method}`);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      return createErrorResponse(id, MCP_ERROR_CODES.INTERNAL_ERROR, message);
+    }
+  }
+  async handleInitialize(id) {
+    return createSuccessResponse(id, {
+      protocolVersion: "2024-11-05",
+      serverInfo: SERVER_INFO,
+      capabilities: CAPABILITIES,
+      instructions: SERVER_INSTRUCTIONS
+    });
+  }
+  async handleToolsList(id) {
+    return createSuccessResponse(id, { tools: ALL_TOOLS });
+  }
+  async handleToolCall(id, params) {
+    const { name, arguments: args = {} } = params;
+    let result;
+    const userId = this.authContext?.userId !== "legacy" ? this.authContext?.userId : void 0;
+    try {
+      if (name.startsWith("collab_session_") || name === "collab_config" || name === "collab_status") {
+        result = await handleSessionTool(this.db, name, args, userId);
+      } else if (name === "collab_claim") {
+        result = await handleClaimTool(this.db, name, args);
+      } else if (name.startsWith("collab_memory_")) {
+        result = await handleMemoryTool(this.db, name, args);
+      } else if (name === "collab_protect") {
+        result = await handleProtectionTool(this.db, name, args);
+      } else {
+        result = createToolResult(`Unknown tool: ${name}`, true);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Tool execution failed";
+      result = createToolResult(message, true);
+    }
+    return createSuccessResponse(id, result);
+  }
+};
 function getMcpTools() {
   return ALL_TOOLS;
 }
@@ -5982,12 +6222,16 @@ async function handleMcpRequest(db, name, args) {
 }
 
 export {
+  loadMigrationsFromDir,
   getDefaultDbPath,
   createLocalDatabase,
+  JsonRpcRequestSchema,
+  generateId,
   VERSION,
   SERVER_NAME,
   SERVER_INSTRUCTIONS,
+  McpServer,
   getMcpTools,
   handleMcpRequest
 };
-//# sourceMappingURL=chunk-V4APNPXF.js.map
+//# sourceMappingURL=chunk-TFGXE3EI.js.map