session-collab-mcp 0.4.7 → 0.5.2

package/src/db/sqlite-adapter.ts

@@ -39,8 +39,7 @@ class SqlitePreparedStatement implements PreparedStatement {
 
   constructor(
     private db: Database.Database,
-    private sql: string,
-    private onWrite?: () => void
+    private sql: string
   ) {}
 
   bind(...values: unknown[]): PreparedStatement {
@@ -66,8 +65,8 @@ class SqlitePreparedStatement implements PreparedStatement {
   async run(): Promise<{ meta: { changes: number } }> {
     const stmt = this.db.prepare(this.sql);
     const result = stmt.run(...this.bindings);
-    // Trigger checkpoint after write
-    this.onWrite?.();
+    // Note: wal_autocheckpoint handles periodic checkpoints automatically
+    // No need to checkpoint after every write - reduces I/O overhead
     return {
       meta: { changes: result.changes },
     };
@@ -104,12 +103,13 @@ class SqliteDatabase implements DatabaseAdapter {
   }
 
   // Force checkpoint to make changes visible to other processes
+  // Only called after batch operations, not after individual writes
   checkpoint(): void {
     this.db.pragma('wal_checkpoint(PASSIVE)');
   }
 
   prepare(sql: string): PreparedStatement {
-    return new SqlitePreparedStatement(this.db, sql, () => this.checkpoint());
+    return new SqlitePreparedStatement(this.db, sql);
   }
 
   async batch(statements: PreparedStatement[]): Promise<QueryResult<unknown>[]> {
@@ -124,7 +124,7 @@ class SqliteDatabase implements DatabaseAdapter {
       });
     });
     const results = transaction();
-    // Checkpoint after batch write
+    // Checkpoint after batch write to ensure visibility to other processes
     this.checkpoint();
     return results;
   }

package/src/db/types.ts

@@ -120,6 +120,62 @@ export interface ClaimFile {
   is_pattern: number; // 0 or 1, SQLite boolean
 }
 
+// Symbol types for fine-grained conflict detection
+export type SymbolType = 'function' | 'class' | 'method' | 'variable' | 'block' | 'other';
+
+export interface ClaimSymbol {
+  id: number;
+  claim_id: string;
+  file_path: string;
+  symbol_name: string;
+  symbol_type: SymbolType;
+  created_at: string;
+}
+
+// Input format for claiming symbols
+export interface SymbolClaim {
+  file: string;
+  symbols: string[];
+  symbol_type?: SymbolType;
+}
+
+// Symbol reference for impact tracking
+export interface SymbolReference {
+  id: number;
+  source_file: string;
+  source_symbol: string;
+  ref_file: string;
+  ref_line: number | null;
+  ref_context: string | null;
+  session_id: string;
+  created_at: string;
+}
+
+// Input format for storing references
+export interface ReferenceInput {
+  source_file: string;
+  source_symbol: string;
+  references: Array<{
+    file: string;
+    line: number;
+    context?: string;
+  }>;
+}
+
+// Impact analysis result
+export interface ImpactInfo {
+  symbol: string;
+  file: string;
+  affected_claims: Array<{
+    claim_id: string;
+    session_name: string | null;
+    intent: string;
+    affected_symbols: string[];
+  }>;
+  reference_count: number;
+  affected_files: string[];
+}
+
 export interface Message {
   id: string;
   from_session_id: string;
@@ -152,4 +208,8 @@ export interface ConflictInfo {
   intent: string;
   scope: ClaimScope;
   created_at: string;
+  // Symbol-level conflict info (optional)
+  symbol_name?: string;
+  symbol_type?: SymbolType;
+  conflict_level: 'file' | 'symbol';
 }

package/src/mcp/schemas.ts

@@ -0,0 +1,200 @@
+// Zod schemas for MCP tool input validation
+import { z } from 'zod';
+
+// Common schemas
+export const sessionIdSchema = z.string().min(1, 'session_id is required');
+export const claimIdSchema = z.string().min(1, 'claim_id is required');
+export const filePathSchema = z.string().min(1);
+export const filesArraySchema = z.array(filePathSchema).min(1, 'At least one file is required');
+
+// Symbol claim schema
+export const symbolClaimSchema = z.object({
+  file: z.string().min(1),
+  symbols: z.array(z.string().min(1)).min(1),
+  symbol_type: z.enum(['function', 'class', 'method', 'variable', 'block', 'other']).optional(),
+});
+
+export const symbolClaimsArraySchema = z.array(symbolClaimSchema);
+
+// Claim scope schema
+export const claimScopeSchema = z.enum(['small', 'medium', 'large']).default('medium');
+
+// Claim status schema
+export const claimStatusSchema = z.enum(['completed', 'abandoned']);
+
+// Session tools input schemas
+export const sessionStartSchema = z.object({
+  project_root: z.string().min(1, 'project_root is required'),
+  name: z.string().optional(),
+  machine_id: z.string().optional(),
+});
+
+export const sessionEndSchema = z.object({
+  session_id: sessionIdSchema,
+  release_claims: z.enum(['complete', 'abandon']).default('abandon'),
+});
+
+export const sessionListSchema = z.object({
+  include_inactive: z.boolean().optional(),
+  project_root: z.string().optional(),
+});
+
+export const sessionHeartbeatSchema = z.object({
+  session_id: sessionIdSchema,
+  current_task: z.string().optional(),
+  todos: z.array(z.object({
+    content: z.string(),
+    status: z.enum(['pending', 'in_progress', 'completed']),
+  })).optional(),
+});
+
+export const statusUpdateSchema = z.object({
+  session_id: sessionIdSchema,
+  current_task: z.string().optional(),
+  todos: z.array(z.object({
+    content: z.string(),
+    status: z.enum(['pending', 'in_progress', 'completed']),
+  })).optional(),
+});
+
+export const configSchema = z.object({
+  session_id: sessionIdSchema,
+  mode: z.enum(['strict', 'smart', 'bypass']).optional(),
+  allow_release_others: z.boolean().optional(),
+  auto_release_stale: z.boolean().optional(),
+  stale_threshold_hours: z.number().min(0).optional(),
+});
+
+// Claim tools input schemas
+export const claimCreateSchema = z.object({
+  session_id: sessionIdSchema,
+  files: z.array(filePathSchema).optional(),
+  symbols: symbolClaimsArraySchema.optional(),
+  intent: z.string().min(1, 'intent is required'),
+  scope: claimScopeSchema.optional(),
+}).refine(
+  (data) => (data.files && data.files.length > 0) || (data.symbols && data.symbols.length > 0),
+  { message: 'Either files or symbols must be provided' }
+);
+
+export const claimCheckSchema = z.object({
+  files: filesArraySchema,
+  symbols: symbolClaimsArraySchema.optional(),
+  session_id: z.string().optional(),
+});
+
+export const claimReleaseSchema = z.object({
+  session_id: sessionIdSchema,
+  claim_id: claimIdSchema,
+  status: claimStatusSchema,
+  summary: z.string().optional(),
+  force: z.boolean().optional(),
+});
+
+export const claimListSchema = z.object({
+  session_id: z.string().optional(),
+  status: z.enum(['active', 'completed', 'abandoned', 'all']).optional(),
+  project_root: z.string().optional(),
+});
+
+// Message tools input schemas
+export const messageSendSchema = z.object({
+  from_session_id: sessionIdSchema,
+  to_session_id: z.string().optional(),
+  content: z.string().min(1, 'content is required'),
+});
+
+export const messageListSchema = z.object({
+  session_id: sessionIdSchema,
+  unread_only: z.boolean().optional(),
+  mark_as_read: z.boolean().optional(),
+});
+
+// Decision tools input schemas
+export const decisionAddSchema = z.object({
+  session_id: sessionIdSchema,
+  category: z.enum(['architecture', 'naming', 'api', 'database', 'ui', 'other']).optional(),
+  title: z.string().min(1, 'title is required'),
+  description: z.string().min(1, 'description is required'),
+});
+
+export const decisionListSchema = z.object({
+  category: z.enum(['architecture', 'naming', 'api', 'database', 'ui', 'other']).optional(),
+  limit: z.number().min(1).max(100).optional(),
+});
+
+// LSP tools input schemas
+// Using z.ZodType to properly type recursive schema
+type LspSymbol = {
+  name: string;
+  kind: number;
+  range?: { start: { line: number; character: number }; end: { line: number; character: number } };
+  children?: LspSymbol[];
+};
+
+export const lspSymbolSchema: z.ZodType<LspSymbol> = z.object({
+  name: z.string(),
+  kind: z.number(),
+  range: z.object({
+    start: z.object({ line: z.number(), character: z.number() }),
+    end: z.object({ line: z.number(), character: z.number() }),
+  }).optional(),
+  children: z.lazy(() => z.array(lspSymbolSchema)).optional(),
+});
+
+export const analyzeSymbolsSchema = z.object({
+  session_id: sessionIdSchema,
+  files: z.array(z.object({
+    file: z.string(),
+    symbols: z.array(lspSymbolSchema),
+  })),
+  check_symbols: z.array(z.string()).optional(),
+  references: z.array(z.object({
+    symbol: z.string(),
+    file: z.string(),
+    references: z.array(z.object({
+      file: z.string(),
+      line: z.number(),
+      context: z.string().optional(),
+    })),
+  })).optional(),
+});
+
+export const validateSymbolsSchema = z.object({
+  file: z.string().min(1),
+  symbols: z.array(z.string().min(1)),
+  lsp_symbols: z.array(lspSymbolSchema),
+});
+
+export const storeReferencesSchema = z.object({
+  session_id: sessionIdSchema,
+  references: z.array(z.object({
+    source_file: z.string(),
+    source_symbol: z.string(),
+    references: z.array(z.object({
+      file: z.string(),
+      line: z.number(),
+      context: z.string().optional(),
+    })),
+  })),
+  clear_existing: z.boolean().optional(),
+});
+
+export const impactAnalysisSchema = z.object({
+  session_id: sessionIdSchema,
+  file: z.string().min(1),
+  symbol: z.string().min(1),
+});
+
+// Helper function to validate and return parsed data or error result
+export function validateInput<T>(
+  schema: z.ZodSchema<T>,
+  data: unknown
+): { success: true; data: T } | { success: false; error: string } {
+  const result = schema.safeParse(data);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  const errors = result.error.errors.map((e) => `${e.path.join('.')}: ${e.message}`).join(', ');
+  return { success: false, error: errors };
+}

package/src/mcp/server.ts

@@ -19,6 +19,7 @@ import { sessionTools, handleSessionTool } from './tools/session';
 import { claimTools, handleClaimTool } from './tools/claim';
 import { messageTools, handleMessageTool } from './tools/message';
 import { decisionTools, handleDecisionTool } from './tools/decision';
+import { lspTools, handleLspTool } from './tools/lsp';
 import type { AuthContext } from '../auth/types';
 import { VERSION, SERVER_NAME, SERVER_INSTRUCTIONS } from '../constants.js';
 
@@ -32,7 +33,7 @@ const CAPABILITIES: McpCapabilities = {
 };
 
 // Combine all tools
-const ALL_TOOLS: McpTool[] = [...sessionTools, ...claimTools, ...messageTools, ...decisionTools];
+const ALL_TOOLS: McpTool[] = [...sessionTools, ...claimTools, ...messageTools, ...decisionTools, ...lspTools];
 
 export class McpServer {
   private authContext?: AuthContext;
@@ -105,6 +106,13 @@ export class McpServer {
         result = await handleMessageTool(this.db, name, args);
       } else if (name.startsWith('collab_decision_')) {
         result = await handleDecisionTool(this.db, name, args);
+      } else if (
+        name === 'collab_analyze_symbols' ||
+        name === 'collab_validate_symbols' ||
+        name === 'collab_store_references' ||
+        name === 'collab_impact_analysis'
+      ) {
+        result = await handleLspTool(this.db, name, args);
       } else {
         result = createToolResult(`Unknown tool: ${name}`, true);
       }
@@ -148,6 +156,13 @@ export async function handleMcpRequest(
       return await handleMessageTool(db, name, args);
     } else if (name.startsWith('collab_decision_')) {
       return await handleDecisionTool(db, name, args);
+    } else if (
+      name === 'collab_analyze_symbols' ||
+      name === 'collab_validate_symbols' ||
+      name === 'collab_store_references' ||
+      name === 'collab_impact_analysis'
+    ) {
+      return await handleLspTool(db, name, args);
     } else {
       return createToolResult(`Unknown tool: ${name}`, true);
     }