session-collab-mcp 0.4.7 → 0.5.2

package/src/db/__tests__/test-helper.ts

@@ -0,0 +1,216 @@
+// Test helper: In-memory SQLite database for testing
+import Database from 'better-sqlite3';
+import type { DatabaseAdapter, PreparedStatement, QueryResult } from '../sqlite-adapter.js';
+
+class TestPreparedStatement implements PreparedStatement {
+  private bindings: unknown[] = [];
+
+  constructor(
+    private db: Database.Database,
+    private sql: string
+  ) {}
+
+  bind(...values: unknown[]): PreparedStatement {
+    this.bindings = values;
+    return this;
+  }
+
+  async first<T>(): Promise<T | null> {
+    const stmt = this.db.prepare(this.sql);
+    const result = stmt.get(...this.bindings) as T | undefined;
+    return result ?? null;
+  }
+
+  async all<T>(): Promise<QueryResult<T>> {
+    const stmt = this.db.prepare(this.sql);
+    const results = stmt.all(...this.bindings) as T[];
+    return {
+      results,
+      meta: { changes: 0, last_row_id: 0 },
+    };
+  }
+
+  async run(): Promise<{ meta: { changes: number } }> {
+    const stmt = this.db.prepare(this.sql);
+    const result = stmt.run(...this.bindings);
+    return {
+      meta: { changes: result.changes },
+    };
+  }
+
+  _run(): Database.RunResult {
+    const stmt = this.db.prepare(this.sql);
+    return stmt.run(...this.bindings);
+  }
+}
+
+// Schema statements split for initialization
+const SCHEMA_STATEMENTS = [
+  // Sessions table
+  `CREATE TABLE IF NOT EXISTS sessions (
+    id TEXT PRIMARY KEY,
+    name TEXT,
+    project_root TEXT NOT NULL,
+    machine_id TEXT,
+    user_id TEXT,
+    created_at TEXT DEFAULT (datetime('now')),
+    last_heartbeat TEXT DEFAULT (datetime('now')),
+    status TEXT DEFAULT 'active' CHECK (status IN ('active', 'inactive', 'terminated')),
+    current_task TEXT,
+    progress TEXT,
+    todos TEXT,
+    config TEXT
+  )`,
+  `CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status)`,
+  `CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_root)`,
+
+  // Claims table
+  `CREATE TABLE IF NOT EXISTS claims (
+    id TEXT PRIMARY KEY,
+    session_id TEXT NOT NULL,
+    intent TEXT NOT NULL,
+    scope TEXT DEFAULT 'medium' CHECK (scope IN ('small', 'medium', 'large')),
+    status TEXT DEFAULT 'active' CHECK (status IN ('active', 'completed', 'abandoned')),
+    created_at TEXT DEFAULT (datetime('now')),
+    updated_at TEXT DEFAULT (datetime('now')),
+    completed_summary TEXT,
+    FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+  )`,
+  `CREATE INDEX IF NOT EXISTS idx_claims_session ON claims(session_id)`,
+  `CREATE INDEX IF NOT EXISTS idx_claims_status ON claims(status)`,
+
+  // Claim files
+  `CREATE TABLE IF NOT EXISTS claim_files (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    claim_id TEXT NOT NULL,
+    file_path TEXT NOT NULL,
+    is_pattern INTEGER DEFAULT 0,
+    FOREIGN KEY (claim_id) REFERENCES claims(id) ON DELETE CASCADE,
+    UNIQUE(claim_id, file_path)
+  )`,
+  `CREATE INDEX IF NOT EXISTS idx_claim_files_path ON claim_files(file_path)`,
+  `CREATE INDEX IF NOT EXISTS idx_claim_files_claim ON claim_files(claim_id)`,
+
+  // Claim symbols
+  `CREATE TABLE IF NOT EXISTS claim_symbols (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    claim_id TEXT NOT NULL,
+    file_path TEXT NOT NULL,
+    symbol_name TEXT NOT NULL,
+    symbol_type TEXT DEFAULT 'function' CHECK (symbol_type IN ('function', 'class', 'method', 'variable', 'block', 'other')),
+    created_at TEXT DEFAULT (datetime('now')),
+    FOREIGN KEY (claim_id) REFERENCES claims(id) ON DELETE CASCADE,
+    UNIQUE(claim_id, file_path, symbol_name)
+  )`,
+  `CREATE INDEX IF NOT EXISTS idx_claim_symbols_path ON claim_symbols(file_path)`,
+  `CREATE INDEX IF NOT EXISTS idx_claim_symbols_name ON claim_symbols(symbol_name)`,
+  `CREATE INDEX IF NOT EXISTS idx_claim_symbols_claim ON claim_symbols(claim_id)`,
+  `CREATE INDEX IF NOT EXISTS idx_claim_symbols_lookup ON claim_symbols(file_path, symbol_name)`,
+
+  // Messages table
+  `CREATE TABLE IF NOT EXISTS messages (
+    id TEXT PRIMARY KEY,
+    from_session_id TEXT NOT NULL,
+    to_session_id TEXT,
+    content TEXT NOT NULL,
+    read_at TEXT,
+    created_at TEXT DEFAULT (datetime('now')),
+    FOREIGN KEY (from_session_id) REFERENCES sessions(id) ON DELETE CASCADE
+  )`,
+  `CREATE INDEX IF NOT EXISTS idx_messages_to ON messages(to_session_id)`,
+  `CREATE INDEX IF NOT EXISTS idx_messages_unread ON messages(to_session_id, read_at)`,
+
+  // Decisions table
+  `CREATE TABLE IF NOT EXISTS decisions (
+    id TEXT PRIMARY KEY,
+    session_id TEXT NOT NULL,
+    category TEXT CHECK (category IN ('architecture', 'naming', 'api', 'database', 'ui', 'other')),
+    title TEXT NOT NULL,
+    description TEXT NOT NULL,
+    created_at TEXT DEFAULT (datetime('now')),
+    FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+  )`,
+  `CREATE INDEX IF NOT EXISTS idx_decisions_category ON decisions(category)`,
+
+  // Symbol references
+  `CREATE TABLE IF NOT EXISTS symbol_references (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    source_file TEXT NOT NULL,
+    source_symbol TEXT NOT NULL,
+    ref_file TEXT NOT NULL,
+    ref_line INTEGER,
+    ref_context TEXT,
+    session_id TEXT NOT NULL,
+    created_at TEXT DEFAULT (datetime('now')),
+    FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE,
+    UNIQUE(source_file, source_symbol, ref_file, ref_line)
+  )`,
+  `CREATE INDEX IF NOT EXISTS idx_symbol_refs_source ON symbol_references(source_file, source_symbol)`,
+  `CREATE INDEX IF NOT EXISTS idx_symbol_refs_ref_file ON symbol_references(ref_file)`,
+  `CREATE INDEX IF NOT EXISTS idx_symbol_refs_session ON symbol_references(session_id)`,
+
+  // Composite indexes for common query patterns
+  `CREATE INDEX IF NOT EXISTS idx_sessions_status_heartbeat ON sessions(status, last_heartbeat)`,
+  `CREATE INDEX IF NOT EXISTS idx_claims_status_session ON claims(status, session_id)`,
+  `CREATE INDEX IF NOT EXISTS idx_claim_files_path_claim ON claim_files(file_path, claim_id)`,
+];
+
+const CLEANUP_STATEMENTS = [
+  'DELETE FROM symbol_references',
+  'DELETE FROM claim_symbols',
+  'DELETE FROM claim_files',
+  'DELETE FROM claims',
+  'DELETE FROM messages',
+  'DELETE FROM decisions',
+  'DELETE FROM sessions',
+];
+
+export class TestDatabase implements DatabaseAdapter {
+  private db: Database.Database;
+
+  constructor() {
+    // Use in-memory database for tests
+    this.db = new Database(':memory:');
+    this.db.pragma('foreign_keys = ON');
+    this.initSchema();
+  }
+
+  private initSchema(): void {
+    for (const sql of SCHEMA_STATEMENTS) {
+      this.db.prepare(sql).run();
+    }
+  }
+
+  prepare(sql: string): PreparedStatement {
+    return new TestPreparedStatement(this.db, sql);
+  }
+
+  async batch(statements: PreparedStatement[]): Promise<QueryResult<unknown>[]> {
+    const transaction = this.db.transaction(() => {
+      return statements.map((stmt) => {
+        const testStmt = stmt as TestPreparedStatement;
+        const result = testStmt._run();
+        return {
+          results: [],
+          meta: { changes: result.changes, last_row_id: Number(result.lastInsertRowid) },
+        };
+      });
+    });
+    return transaction();
+  }
+
+  close(): void {
+    this.db.close();
+  }
+
+  // Helper to reset database between tests
+  reset(): void {
+    for (const sql of CLEANUP_STATEMENTS) {
+      this.db.prepare(sql).run();
+    }
+  }
+}
+
+export function createTestDatabase(): TestDatabase {
+  return new TestDatabase();
+}

package/src/db/queries.ts

@@ -14,6 +14,8 @@ import type {
   TodoItem,
   SessionProgress,
   SessionConfig,
+  SymbolClaim,
+  SymbolType,
 } from './types';
 
 // Helper to generate UUID v4
@@ -262,8 +264,9 @@ export async function createClaim(
     files: string[];
     intent: string;
     scope?: ClaimScope;
+    symbols?: SymbolClaim[];
   }
-): Promise<{ claim: Claim; files: string[] }> {
+): Promise<{ claim: Claim; files: string[]; symbols?: SymbolClaim[] }> {
   const id = generateId();
   const now = new Date().toISOString();
   const scope = params.scope ?? 'medium';
@@ -283,7 +286,23 @@ export async function createClaim(
       .bind(id, filePath, isPattern);
   });
 
-  await db.batch([claimStatement, ...fileStatements]);
+  // Add symbol claims if provided
+  const symbolStatements: ReturnType<typeof db.prepare>[] = [];
+  if (params.symbols && params.symbols.length > 0) {
+    for (const symbolClaim of params.symbols) {
+      for (const symbolName of symbolClaim.symbols) {
+        symbolStatements.push(
+          db
+            .prepare(
+              'INSERT INTO claim_symbols (claim_id, file_path, symbol_name, symbol_type, created_at) VALUES (?, ?, ?, ?, ?)'
+            )
+            .bind(id, symbolClaim.file, symbolName, symbolClaim.symbol_type ?? 'function', now)
+        );
+      }
+    }
+  }
+
+  await db.batch([claimStatement, ...fileStatements, ...symbolStatements]);
 
   return {
     claim: {
@@ -297,22 +316,41 @@ export async function createClaim(
       completed_summary: null,
     },
     files: params.files,
+    symbols: params.symbols,
   };
 }
 
 export async function getClaim(db: DatabaseAdapter, id: string): Promise<ClaimWithFiles | null> {
-  const claim = await db.prepare('SELECT * FROM claims WHERE id = ?').bind(id).first<Claim>();
-
-  if (!claim) return null;
-
-  const files = await db.prepare('SELECT file_path FROM claim_files WHERE claim_id = ?').bind(id).all<{ file_path: string }>();
+  // Single query with JOIN to avoid N+1 problem
+  const result = await db
+    .prepare(
+      `SELECT
+        c.id, c.session_id, c.intent, c.scope, c.status,
+        c.created_at, c.updated_at, c.completed_summary,
+        s.name as session_name,
+        GROUP_CONCAT(cf.file_path, '|||') as file_paths
+      FROM claims c
+      LEFT JOIN sessions s ON c.session_id = s.id
+      LEFT JOIN claim_files cf ON c.id = cf.claim_id
+      WHERE c.id = ?
+      GROUP BY c.id`
+    )
+    .bind(id)
+    .first<Claim & { session_name: string | null; file_paths: string | null }>();
 
-  const session = await db.prepare('SELECT name FROM sessions WHERE id = ?').bind(claim.session_id).first<{ name: string | null }>();
+  if (!result) return null;
 
   return {
-    ...claim,
-    files: files.results.map((f) => f.file_path),
-    session_name: session?.name ?? null,
+    id: result.id,
+    session_id: result.session_id,
+    intent: result.intent,
+    scope: result.scope,
+    status: result.status,
+    created_at: result.created_at,
+    updated_at: result.updated_at,
+    completed_summary: result.completed_summary,
+    files: result.file_paths ? result.file_paths.split('|||') : [],
+    session_name: result.session_name,
   };
 }
 
@@ -384,47 +422,187 @@ export async function listClaims(
 export async function checkConflicts(
   db: DatabaseAdapter,
   files: string[],
-  excludeSessionId?: string
+  excludeSessionId?: string,
+  symbols?: SymbolClaim[]
 ): Promise<ConflictInfo[]> {
   const conflicts: ConflictInfo[] = [];
 
-  for (const filePath of files) {
-    // Check for exact matches or pattern overlaps
-    let query = `
-      SELECT
-        c.id as claim_id,
-        c.session_id,
-        s.name as session_name,
-        cf.file_path,
-        c.intent,
-        c.scope,
-        c.created_at
-      FROM claim_files cf
-      JOIN claims c ON cf.claim_id = c.id
-      JOIN sessions s ON c.session_id = s.id
-      WHERE c.status = 'active'
-        AND s.status = 'active'
-        AND (cf.file_path = ? OR (cf.is_pattern = 1 AND ? GLOB cf.file_path))
-    `;
-    const bindings: string[] = [filePath, filePath];
-
-    if (excludeSessionId) {
-      query += ' AND c.session_id != ?';
-      bindings.push(excludeSessionId);
+  // Build a map of file -> symbols for quick lookup
+  const symbolsByFile = new Map<string, Set<string>>();
+  if (symbols && symbols.length > 0) {
+    for (const sc of symbols) {
+      const existing = symbolsByFile.get(sc.file) ?? new Set();
+      for (const sym of sc.symbols) {
+        existing.add(sym);
+      }
+      symbolsByFile.set(sc.file, existing);
     }
+  }
 
-    const result = await db
-      .prepare(query)
-      .bind(...bindings)
-      .all<ConflictInfo>();
-
-    conflicts.push(...result.results);
+  for (const filePath of files) {
+    const requestedSymbols = symbolsByFile.get(filePath);
+
+    // First check if there are symbol-level claims for this file
+    if (requestedSymbols && requestedSymbols.size > 0) {
+      // Symbol-level conflict check
+      let symbolQuery = `
+        SELECT
+          c.id as claim_id,
+          c.session_id,
+          s.name as session_name,
+          cs.file_path,
+          c.intent,
+          c.scope,
+          c.created_at,
+          cs.symbol_name,
+          cs.symbol_type
+        FROM claim_symbols cs
+        JOIN claims c ON cs.claim_id = c.id
+        JOIN sessions s ON c.session_id = s.id
+        WHERE c.status = 'active'
+          AND s.status = 'active'
+          AND cs.file_path = ?
+          AND cs.symbol_name IN (${Array.from(requestedSymbols).map(() => '?').join(',')})
+      `;
+      const symbolBindings: string[] = [filePath, ...Array.from(requestedSymbols)];
+
+      if (excludeSessionId) {
+        symbolQuery += ' AND c.session_id != ?';
+        symbolBindings.push(excludeSessionId);
+      }
+
+      const symbolResult = await db
+        .prepare(symbolQuery)
+        .bind(...symbolBindings)
+        .all<ConflictInfo & { symbol_name: string; symbol_type: SymbolType }>();
+
+      for (const r of symbolResult.results) {
+        conflicts.push({
+          ...r,
+          conflict_level: 'symbol',
+        });
+      }
+
+      // Also check if there's a file-level claim (no symbols = whole file claimed)
+      let fileClaimQuery = `
+        SELECT
+          c.id as claim_id,
+          c.session_id,
+          s.name as session_name,
+          cf.file_path,
+          c.intent,
+          c.scope,
+          c.created_at
+        FROM claim_files cf
+        JOIN claims c ON cf.claim_id = c.id
+        JOIN sessions s ON c.session_id = s.id
+        WHERE c.status = 'active'
+          AND s.status = 'active'
+          AND (cf.file_path = ? OR (cf.is_pattern = 1 AND ? GLOB cf.file_path))
+          AND NOT EXISTS (
+            SELECT 1 FROM claim_symbols cs WHERE cs.claim_id = c.id AND cs.file_path = cf.file_path
+          )
+      `;
+      const fileClaimBindings: string[] = [filePath, filePath];
+
+      if (excludeSessionId) {
+        fileClaimQuery += ' AND c.session_id != ?';
+        fileClaimBindings.push(excludeSessionId);
+      }
+
+      const fileClaimResult = await db
+        .prepare(fileClaimQuery)
+        .bind(...fileClaimBindings)
+        .all<Omit<ConflictInfo, 'conflict_level'>>();
+
+      for (const r of fileClaimResult.results) {
+        conflicts.push({
+          ...r,
+          conflict_level: 'file',
+        });
+      }
+    } else {
+      // No symbols specified - check both file-level and symbol-level claims
+      // File-level claims (whole file)
+      let fileQuery = `
+        SELECT
+          c.id as claim_id,
+          c.session_id,
+          s.name as session_name,
+          cf.file_path,
+          c.intent,
+          c.scope,
+          c.created_at
+        FROM claim_files cf
+        JOIN claims c ON cf.claim_id = c.id
+        JOIN sessions s ON c.session_id = s.id
+        WHERE c.status = 'active'
+          AND s.status = 'active'
+          AND (cf.file_path = ? OR (cf.is_pattern = 1 AND ? GLOB cf.file_path))
+      `;
+      const fileBindings: string[] = [filePath, filePath];
+
+      if (excludeSessionId) {
+        fileQuery += ' AND c.session_id != ?';
+        fileBindings.push(excludeSessionId);
+      }
+
+      const fileResult = await db
+        .prepare(fileQuery)
+        .bind(...fileBindings)
+        .all<Omit<ConflictInfo, 'conflict_level'>>();
+
+      for (const r of fileResult.results) {
+        conflicts.push({
+          ...r,
+          conflict_level: 'file',
+        });
+      }
+
+      // Symbol-level claims on this file
+      let symbolOnlyQuery = `
+        SELECT DISTINCT
+          c.id as claim_id,
+          c.session_id,
+          s.name as session_name,
+          cs.file_path,
+          c.intent,
+          c.scope,
+          c.created_at,
+          cs.symbol_name,
+          cs.symbol_type
+        FROM claim_symbols cs
+        JOIN claims c ON cs.claim_id = c.id
+        JOIN sessions s ON c.session_id = s.id
+        WHERE c.status = 'active'
+          AND s.status = 'active'
+          AND cs.file_path = ?
+      `;
+      const symbolOnlyBindings: string[] = [filePath];
+
+      if (excludeSessionId) {
+        symbolOnlyQuery += ' AND c.session_id != ?';
+        symbolOnlyBindings.push(excludeSessionId);
+      }
+
+      const symbolOnlyResult = await db
+        .prepare(symbolOnlyQuery)
+        .bind(...symbolOnlyBindings)
+        .all<ConflictInfo & { symbol_name: string; symbol_type: SymbolType }>();
+
+      for (const r of symbolOnlyResult.results) {
+        conflicts.push({
+          ...r,
+          conflict_level: 'symbol',
+        });
+      }
+    }
   }
 
-  // Deduplicate by claim_id + file_path
+  // Deduplicate by claim_id + file_path + symbol_name
   const seen = new Set<string>();
   return conflicts.filter((c) => {
-    const key = `${c.claim_id}:${c.file_path}`;
+    const key = `${c.claim_id}:${c.file_path}:${c.symbol_name ?? ''}`;
     if (seen.has(key)) return false;
     seen.add(key);
     return true;
@@ -575,3 +753,158 @@ export async function listDecisions(
 
   return result.results;
 }
+
+// ============ Reference Queries ============
+
+import type { ReferenceInput, SymbolReference, ImpactInfo } from './types';
+
+export async function storeReferences(
+  db: DatabaseAdapter,
+  sessionId: string,
+  references: ReferenceInput[]
+): Promise<{ stored: number; skipped: number }> {
+  let stored = 0;
+  let skipped = 0;
+  const now = new Date().toISOString();
+
+  for (const ref of references) {
+    for (const r of ref.references) {
+      try {
+        await db
+          .prepare(
+            `INSERT OR IGNORE INTO symbol_references
+             (source_file, source_symbol, ref_file, ref_line, ref_context, session_id, created_at)
+             VALUES (?, ?, ?, ?, ?, ?, ?)`
+          )
+          .bind(ref.source_file, ref.source_symbol, r.file, r.line, r.context ?? null, sessionId, now)
+          .run();
+        stored++;
+      } catch {
+        skipped++;
+      }
+    }
+  }
+
+  return { stored, skipped };
+}
+
+export async function getReferencesForSymbol(
+  db: DatabaseAdapter,
+  sourceFile: string,
+  sourceSymbol: string
+): Promise<SymbolReference[]> {
+  const result = await db
+    .prepare(
+      `SELECT * FROM symbol_references
+       WHERE source_file = ? AND source_symbol = ?
+       ORDER BY ref_file, ref_line`
+    )
+    .bind(sourceFile, sourceSymbol)
+    .all<SymbolReference>();
+
+  return result.results;
+}
+
+export async function getReferencesToFile(
+  db: DatabaseAdapter,
+  filePath: string
+): Promise<SymbolReference[]> {
+  const result = await db
+    .prepare(
+      `SELECT * FROM symbol_references
+       WHERE ref_file = ?
+       ORDER BY source_file, source_symbol`
+    )
+    .bind(filePath)
+    .all<SymbolReference>();
+
+  return result.results;
+}
+
+export async function analyzeClaimImpact(
+  db: DatabaseAdapter,
+  sourceFile: string,
+  sourceSymbol: string,
+  excludeSessionId?: string
+): Promise<ImpactInfo> {
+  // Get all references to this symbol
+  const refs = await getReferencesForSymbol(db, sourceFile, sourceSymbol);
+
+  // Get unique files that reference this symbol
+  const affectedFiles = [...new Set(refs.map((r) => r.ref_file))];
+
+  // Check if any of these files have active claims
+  const affectedClaims: ImpactInfo['affected_claims'] = [];
+
+  if (affectedFiles.length > 0) {
+    const placeholders = affectedFiles.map(() => '?').join(',');
+    let query = `
+      SELECT DISTINCT
+        c.id as claim_id,
+        s.name as session_name,
+        c.intent,
+        cf.file_path
+      FROM claim_files cf
+      JOIN claims c ON cf.claim_id = c.id
+      JOIN sessions s ON c.session_id = s.id
+      WHERE c.status = 'active'
+        AND s.status = 'active'
+        AND cf.file_path IN (${placeholders})
+    `;
+    const bindings: string[] = [...affectedFiles];
+
+    if (excludeSessionId) {
+      query += ' AND c.session_id != ?';
+      bindings.push(excludeSessionId);
+    }
+
+    const claimResults = await db
+      .prepare(query)
+      .bind(...bindings)
+      .all<{ claim_id: string; session_name: string | null; intent: string; file_path: string }>();
+
+    // Group by claim
+    const claimMap = new Map<string, { session_name: string | null; intent: string; files: string[] }>();
+    for (const r of claimResults.results) {
+      const existing = claimMap.get(r.claim_id);
+      if (existing) {
+        existing.files.push(r.file_path);
+      } else {
+        claimMap.set(r.claim_id, {
+          session_name: r.session_name,
+          intent: r.intent,
+          files: [r.file_path],
+        });
+      }
+    }
+
+    for (const [claimId, data] of claimMap) {
+      affectedClaims.push({
+        claim_id: claimId,
+        session_name: data.session_name,
+        intent: data.intent,
+        affected_symbols: data.files,
+      });
+    }
+  }
+
+  return {
+    symbol: sourceSymbol,
+    file: sourceFile,
+    affected_claims: affectedClaims,
+    reference_count: refs.length,
+    affected_files: affectedFiles,
+  };
+}
+
+export async function clearSessionReferences(
+  db: DatabaseAdapter,
+  sessionId: string
+): Promise<number> {
+  const result = await db
+    .prepare('DELETE FROM symbol_references WHERE session_id = ?')
+    .bind(sessionId)
+    .run();
+
+  return result.meta.changes;
+}