@in-the-loop-labs/pair-review 1.3.2 → 1.4.0

package/src/ai/provider.js

@@ -494,6 +494,28 @@ function getRegisteredProviderIds() {
   return Array.from(providerRegistry.keys());
 }
 
+/**
+ * Merge config-override models with a provider's built-in models.
+ * Config models with matching IDs replace built-ins; config models with new IDs
+ * are appended. If no config models exist, returns built-ins unchanged.
+ *
+ * @param {Array<Object>} builtInModels - Models from ProviderClass.getModels()
+ * @param {Array<Object>|undefined} configModels - Models from config overrides
+ * @returns {Array<Object>} Merged model list
+ */
+function mergeModels(builtInModels, configModels) {
+  if (!configModels || configModels.length === 0) {
+    return builtInModels;
+  }
+  const configById = new Map(configModels.map(m => [m.id, m]));
+  // Replace overridden built-ins in-place to preserve display order
+  const merged = builtInModels.map(m => configById.get(m.id) || m);
+  // Append config models with new IDs not present in built-ins
+  const builtInIds = new Set(builtInModels.map(m => m.id));
+  const newModels = configModels.filter(m => !builtInIds.has(m.id));
+  return [...merged, ...newModels];
+}
+
 /**
  * Get provider info for all registered providers
  * Uses config overrides for models/installInstructions if available
@@ -504,10 +526,10 @@ function getAllProvidersInfo() {
   for (const [id, ProviderClass] of providerRegistry) {
     const overrides = providerConfigOverrides.get(id);
 
-    // Use overridden models if available, otherwise use built-in
-    const models = overrides?.models || ProviderClass.getModels();
+    // Merge config models with built-in models (config wins on ID collision)
+    const models = mergeModels(ProviderClass.getModels(), overrides?.models);
 
-    // Resolve default model from (potentially overridden) models array
+    // Resolve default model from merged models array
     const defaultModel = resolveDefaultModel(models) || ProviderClass.getDefaultModel();
 
     // Use overridden install instructions if available
@@ -545,9 +567,11 @@ function createProvider(providerId, model = null) {
   // Determine the actual model to use
   let actualModel = model;
   if (!actualModel) {
-    // If models are overridden, resolve default from them
-    if (overrides?.models) {
-      actualModel = resolveDefaultModel(overrides.models);
+    // Resolve default from merged models (config + built-in).
+    // Checks both sources because some providers (e.g., Pi) define built-in
+    // modes with default:true that aren't in config overrides.
+    if (overrides?.models || ProviderClass.getModels().length > 0) {
+      actualModel = resolveDefaultModel(mergeModels(ProviderClass.getModels(), overrides?.models));
     }
     // Fall back to provider's built-in default
     if (!actualModel) {
@@ -572,9 +596,9 @@ function getTierForModel(providerId, modelId) {
     return null;
   }
 
-  // Use overridden models if available
+  // Merge config models with built-in models
   const overrides = providerConfigOverrides.get(providerId);
-  const models = overrides?.models || ProviderClass.getModels();
+  const models = mergeModels(ProviderClass.getModels(), overrides?.models);
 
   const model = models.find(m => m.id === modelId);
   return model?.tier || null;

package/src/ai/stream-parser.js

@@ -71,8 +71,9 @@ function extractToolDetail(input, cwd) {
   // Command execution (bash, shell, etc.)
   if (parsed.command) return parsed.command;
 
-  // Task/agent description (Claude Code Task tool, etc.)
+  // Task/agent description (Claude Code Task tool, Pi task extension, etc.)
   if (parsed.description) return parsed.description;
+  if (parsed.task) return parsed.task;
 
   // File path (various field naming conventions)
   const rawPath = parsed.file_path || parsed.filePath || parsed.path;
@@ -462,6 +463,172 @@ function parseCursorAgentLine(line, options = {}) {
   }
 }
 
+/**
+ * Parse a single Pi JSONL line into a normalized event.
+ * Returns null if the line should not be emitted.
+ *
+ * Pi JSONL event types:
+ * - message_update (assistantMessageEvent.type === 'text_delta') → assistant_text
+ * - message_end (role: 'assistant', content blocks with text) → assistant_text
+ * - tool_execution_start (toolName, args) → tool_use
+ * - session, turn_start, turn_end, message_start, tool_execution_update,
+ *   tool_execution_end, agent_start, agent_end → filtered out
+ *
+ * @param {string} line - A single JSONL line from Pi stdout
+ * @param {Object} [options] - Parse options
+ * @param {string} [options.cwd] - Working directory to strip from file paths
+ * @returns {{ type: string, text: string, timestamp: number } | null}
+ */
+function parsePiLine(line, options = {}) {
+  if (!line || !line.trim()) return null;
+
+  const { cwd } = options;
+
+  try {
+    const event = JSON.parse(line);
+    const eventType = event.type;
+
+    // Streaming text deltas from message_update events
+    if (eventType === 'message_update') {
+      const assistantEvent = event.assistantMessageEvent;
+      if (assistantEvent?.type === 'text_delta' && assistantEvent?.delta?.trim()) {
+        return {
+          type: 'assistant_text',
+          text: truncateSnippet(assistantEvent.delta),
+          timestamp: Date.now()
+        };
+      }
+      return null;
+    }
+
+    // Complete assistant message from message_end
+    if (eventType === 'message_end' && event.message?.role === 'assistant') {
+      const content = event.message.content;
+      if (Array.isArray(content)) {
+        for (const block of content) {
+          if (block.type === 'text' && block.text?.trim()) {
+            return {
+              type: 'assistant_text',
+              text: truncateSnippet(block.text),
+              timestamp: Date.now()
+            };
+          }
+        }
+      } else if (typeof content === 'string' && content.trim()) {
+        return {
+          type: 'assistant_text',
+          text: truncateSnippet(content),
+          timestamp: Date.now()
+        };
+      }
+      return null;
+    }
+
+    // Tool execution start events
+    if (eventType === 'tool_execution_start') {
+      const toolName = event.toolName || 'unknown';
+      const detail = extractToolDetail(event.args, cwd);
+      const text = detail ? `${toolName}: ${detail}` : toolName;
+      return {
+        type: 'tool_use',
+        text: truncateSnippet(text),
+        timestamp: Date.now()
+      };
+    }
+
+    // Tool execution end — emit for task tools to show completion status
+    if (eventType === 'tool_execution_end') {
+      const toolName = event.toolName || '';
+      if (toolName === 'task') {
+        const isError = event.isError || false;
+        const result = event.result || '';
+        // Extract a short summary from the result
+        let summary = '';
+        if (typeof result === 'string') {
+          // First non-empty line as preview
+          const firstLine = result.split('\n').find(l => l.trim());
+          if (firstLine) summary = firstLine.trim();
+        }
+        const status = isError ? '✗' : '✓';
+        const text = summary
+          ? `task ${status}: ${summary}`
+          : `task ${status}`;
+        return {
+          type: 'tool_use',
+          text: truncateSnippet(text),
+          timestamp: Date.now()
+        };
+      }
+    }
+
+    // session, turn_start, turn_end, message_start, tool_execution_update,
+    // tool_execution_end (non-task), agent_start, agent_end — never emit
+    return null;
+  } catch {
+    // Best-effort side channel — silently ignore non-JSON or malformed lines.
+    return null;
+  }
+}
+
+/**
+ * Create a stateful Pi line parser that accumulates text_delta fragments
+ * before emitting. This prevents flooding the UI with tiny text updates.
+ *
+ * Accumulates text_delta content and only emits an assistant_text event
+ * when enough text has been collected (>= 80 chars). When a non-text-delta
+ * event arrives (tool_execution_start, message_end, etc.), accumulated text
+ * is discarded in favor of the more informative event.
+ *
+ * The returned function has the same signature as parsePiLine and can be
+ * used as a drop-in replacement with StreamParser.
+ *
+ * @returns {Function} Stateful line parser with same signature as parsePiLine
+ */
+function createPiLineParser() {
+  let accumulatedDelta = '';
+
+  return function parsePiLineBuffered(line, options = {}) {
+    if (!line || !line.trim()) return null;
+
+    try {
+      const event = JSON.parse(line);
+      const eventType = event.type;
+
+      // Accumulate text_delta fragments instead of emitting each one
+      if (eventType === 'message_update') {
+        const assistantEvent = event.assistantMessageEvent;
+        if (assistantEvent?.type === 'text_delta' && assistantEvent?.delta) {
+          accumulatedDelta += assistantEvent.delta;
+          // Only emit when we have accumulated a meaningful chunk
+          if (accumulatedDelta.length >= 80) {
+            const text = accumulatedDelta;
+            accumulatedDelta = '';
+            return {
+              type: 'assistant_text',
+              text: truncateSnippet(text),
+              timestamp: Date.now()
+            };
+          }
+          // Not enough accumulated yet — suppress this event
+          return null;
+        }
+        return null;
+      }
+
+      // Non-text-delta event: discard accumulated text (the real event is
+      // more informative) and reset the buffer. The accumulated deltas are
+      // only preview snippets; authoritative text extraction happens in
+      // parsePiResponse.
+      accumulatedDelta = '';
+
+      // Fall through to stateless parsing for non-text-delta events
+      return parsePiLine(line, options);
+    } catch {
+      return null;
+    }
+  };
+}
+
 module.exports = {
   StreamParser,
   truncateSnippet,
@@ -471,5 +638,7 @@ module.exports = {
   parseCodexLine,
   parseGeminiLine,
   parseOpenCodeLine,
-  parseCursorAgentLine
+  parseCursorAgentLine,
+  parsePiLine,
+  createPiLineParser
 };

package/src/config.js

@@ -13,7 +13,7 @@ const DEFAULT_CONFIG = {
   github_token: "",
   port: 7247,
   theme: "light",
-  default_provider: "claude",  // AI provider: 'claude', 'gemini', 'codex', 'copilot', 'opencode'
+  default_provider: "claude",  // AI provider: 'claude', 'gemini', 'codex', 'copilot', 'opencode', 'cursor-agent', 'pi'
   default_model: "opus",       // Model within the provider (e.g., 'opus' for Claude, 'gemini-2.5-pro' for Gemini)
   worktree_retention_days: 7,
   dev_mode: false,  // When true, disables static file caching for development

package/src/database.js

@@ -9,7 +9,7 @@ const DB_PATH = path.join(getConfigDir(), 'database.db');
 /**
  * Current schema version - increment this when adding new migrations
  */
-const CURRENT_SCHEMA_VERSION = 13;
+const CURRENT_SCHEMA_VERSION = 14;
 
 /**
  * Database schema SQL statements
@@ -30,7 +30,8 @@ const SCHEMA_SQL = {
       review_type TEXT DEFAULT 'pr' CHECK(review_type IN ('pr', 'local')),
       local_path TEXT,
       local_head_sha TEXT,
-      summary TEXT
+      summary TEXT,
+      name TEXT
     )
   `,
 
@@ -146,6 +147,17 @@ const SCHEMA_SQL = {
     )
   `,
 
+  local_diffs: `
+    CREATE TABLE IF NOT EXISTS local_diffs (
+      review_id INTEGER PRIMARY KEY,
+      diff_text TEXT,
+      stats TEXT,
+      digest TEXT,
+      captured_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      FOREIGN KEY (review_id) REFERENCES reviews(id) ON DELETE CASCADE
+    )
+  `,
+
   github_reviews: `
     CREATE TABLE IF NOT EXISTS github_reviews (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -212,6 +224,20 @@ function columnExists(db, table, column) {
   return rows ? rows.some(row => row.name === column) : false;
 }
 
+/**
+ * Helper to check if a table exists in the database
+ * Used by migrations to safely create tables idempotently
+ * @param {Database} db - Database instance
+ * @param {string} tableName - Table name
+ * @returns {boolean} True if table exists
+ */
+function tableExists(db, tableName) {
+  const row = db.prepare(
+    `SELECT name FROM sqlite_master WHERE type='table' AND name=?`
+  ).get(tableName);
+  return !!row;
+}
+
 const MIGRATIONS = {
   // Migration to version 1: handles all legacy column additions
   1: (db) => {
@@ -234,14 +260,6 @@ const MIGRATIONS = {
       }
     };
 
-    // Helper to check if table exists
-    const tableExists = (tableName) => {
-      const row = db.prepare(
-        `SELECT name FROM sqlite_master WHERE type='table' AND name=?`
-      ).get(tableName);
-      return !!row;
-    };
-
     // Add columns to comments table
     addColumnIfNotExists('comments', 'diff_position', 'INTEGER');
     addColumnIfNotExists('comments', 'side', "TEXT DEFAULT 'RIGHT'");
@@ -252,7 +270,7 @@ const MIGRATIONS = {
     addColumnIfNotExists('reviews', 'custom_instructions', 'TEXT');
 
     // Create repo_settings table if not exists
-    const hasRepoSettings = tableExists('repo_settings');
+    const hasRepoSettings = tableExists(db, 'repo_settings');
     if (!hasRepoSettings) {
       console.log('  Creating repo_settings table...');
       db.exec(SCHEMA_SQL.repo_settings);
@@ -280,16 +298,8 @@ const MIGRATIONS = {
   3: (db) => {
     console.log('Running migration to schema version 3...');
 
-    // Helper to check if table exists
-    const tableExists = (tableName) => {
-      const row = db.prepare(
-        `SELECT name FROM sqlite_master WHERE type='table' AND name=?`
-      ).get(tableName);
-      return !!row;
-    };
-
     // First ensure pr_metadata table exists
-    const hasPrMetadata = tableExists('pr_metadata');
+    const hasPrMetadata = tableExists(db, 'pr_metadata');
     if (!hasPrMetadata) {
       console.log('  Creating pr_metadata table...');
       db.exec(SCHEMA_SQL.pr_metadata);
@@ -451,16 +461,8 @@ const MIGRATIONS = {
   8: (db) => {
     console.log('Running migration to schema version 8...');
 
-    // Helper to check if table exists
-    const tableExists = (tableName) => {
-      const row = db.prepare(
-        `SELECT name FROM sqlite_master WHERE type='table' AND name=?`
-      ).get(tableName);
-      return !!row;
-    };
-
     // Create analysis_runs table if it doesn't exist
-    if (!tableExists('analysis_runs')) {
+    if (!tableExists(db, 'analysis_runs')) {
       db.exec(`
         CREATE TABLE analysis_runs (
           id TEXT PRIMARY KEY,
@@ -609,16 +611,8 @@ const MIGRATIONS = {
   13: (db) => {
     console.log('Running migration to schema version 13...');
 
-    // Helper to check if table exists
-    const tableExists = (tableName) => {
-      const row = db.prepare(
-        `SELECT name FROM sqlite_master WHERE type='table' AND name=?`
-      ).get(tableName);
-      return !!row;
-    };
-
     // Create github_reviews table if it doesn't exist
-    if (!tableExists('github_reviews')) {
+    if (!tableExists(db, 'github_reviews')) {
       db.exec(`
         CREATE TABLE github_reviews (
           id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -644,6 +638,51 @@ const MIGRATIONS = {
     }
 
     console.log('Migration to schema version 13 complete');
+  },
+
+  // Migration to version 14: adds name column to reviews and creates local_diffs table
+  14: (db) => {
+    console.log('Running migration to schema version 14...');
+
+    // Add name column to reviews if it doesn't exist
+    const hasName = columnExists(db, 'reviews', 'name');
+    if (!hasName) {
+      try {
+        db.prepare(`ALTER TABLE reviews ADD COLUMN name TEXT`).run();
+        console.log('  Added name column to reviews');
+      } catch (error) {
+        // Ignore duplicate column errors (race condition protection)
+        if (!error.message.includes('duplicate column name')) {
+          throw error;
+        }
+        console.log('  Column name already exists (race condition)');
+      }
+    } else {
+      console.log('  Column name already exists');
+    }
+
+    // Create local_diffs table if it doesn't exist
+    if (!tableExists(db, 'local_diffs')) {
+      db.exec(`
+        CREATE TABLE local_diffs (
+          review_id INTEGER PRIMARY KEY,
+          diff_text TEXT,
+          stats TEXT,
+          digest TEXT,
+          captured_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+          FOREIGN KEY (review_id) REFERENCES reviews(id) ON DELETE CASCADE
+        )
+      `);
+      console.log('  Created local_diffs table');
+    } else {
+      console.log('  Table local_diffs already exists');
+    }
+
+    // Add index for listing local sessions (WHERE review_type = 'local' ORDER BY updated_at DESC)
+    db.exec('CREATE INDEX IF NOT EXISTS idx_reviews_type_updated ON reviews(review_type, updated_at DESC)');
+    console.log('  Created index idx_reviews_type_updated');
+
+    console.log('Migration to schema version 14 complete');
   }
 };
 
@@ -1808,6 +1847,11 @@ class ReviewRepository {
       params.push(updates.summary);
     }
 
+    if (updates.name !== undefined) {
+      setClauses.push('name = ?');
+      params.push(updates.name);
+    }
+
     if (updates.submittedAt !== undefined) {
       setClauses.push('submitted_at = ?');
       const submittedAt = updates.submittedAt instanceof Date
@@ -2037,7 +2081,7 @@ class ReviewRepository {
     const row = await queryOne(this.db, `
       SELECT id, pr_number, repository, status, review_id,
              created_at, updated_at, submitted_at, review_data, custom_instructions,
-             review_type, local_path, local_head_sha, summary
+             review_type, local_path, local_head_sha, summary, name
       FROM reviews
       WHERE review_type = 'local' AND local_path = ? AND local_head_sha = ?
     `, [localPath, localHeadSha]);
@@ -2059,7 +2103,7 @@ class ReviewRepository {
     const row = await queryOne(this.db, `
       SELECT id, pr_number, repository, status, review_id,
              created_at, updated_at, submitted_at, review_data, custom_instructions,
-             review_type, local_path, local_head_sha, summary
+             review_type, local_path, local_head_sha, summary, name
       FROM reviews
       WHERE id = ? AND review_type = 'local'
     `, [id]);
@@ -2099,6 +2143,92 @@ class ReviewRepository {
 
     return this.createReview({ prNumber, repository, summary });
   }
+
+  /**
+   * List local review sessions with cursor-based pagination
+   * @param {Object} options - Pagination options
+   * @param {number} [options.limit=10] - Maximum number of sessions to return
+   * @param {string} [options.before] - ISO timestamp cursor (return sessions updated before this)
+   * @returns {Promise<{sessions: Array<Object>, hasMore: boolean}>}
+   */
+  async listLocalSessions({ limit = 10, before } = {}) {
+    const params = [];
+    let whereClause = "WHERE review_type = 'local'";
+
+    if (before) {
+      whereClause += ' AND updated_at < ?';
+      params.push(before);
+    }
+
+    // Fetch one extra to determine hasMore
+    params.push(limit + 1);
+
+    const rows = await query(this.db, `
+      SELECT id, name, repository, local_path, local_head_sha, created_at, updated_at
+      FROM reviews
+      ${whereClause}
+      ORDER BY updated_at DESC
+      LIMIT ?
+    `, params);
+
+    const hasMore = rows.length > limit;
+    const sessions = hasMore ? rows.slice(0, limit) : rows;
+
+    return { sessions, hasMore };
+  }
+
+  /**
+   * Save or update a local diff snapshot in the database
+   * Uses INSERT OR REPLACE for upsert behavior
+   * @param {number} reviewId - Review ID
+   * @param {Object} diffData - Diff data to persist
+   * @param {string} diffData.diff - The diff text content
+   * @param {Object} diffData.stats - Stats object (will be JSON-stringified)
+   * @param {string} [diffData.digest] - Content digest for staleness detection
+   * @returns {Promise<void>}
+   */
+  async saveLocalDiff(reviewId, { diff, stats, digest }) {
+    await run(this.db, `
+      INSERT OR REPLACE INTO local_diffs (review_id, diff_text, stats, digest, captured_at)
+      VALUES (?, ?, ?, ?, CURRENT_TIMESTAMP)
+    `, [reviewId, diff || '', JSON.stringify(stats || {}), digest || null]);
+  }
+
+  /**
+   * Get a persisted local diff from the database
+   * @param {number} reviewId - Review ID
+   * @returns {Promise<{diff: string, stats: Object, digest: string|null}|null>}
+   */
+  async getLocalDiff(reviewId) {
+    const row = await queryOne(this.db, `
+      SELECT diff_text, stats, digest FROM local_diffs WHERE review_id = ?
+    `, [reviewId]);
+
+    if (!row) return null;
+
+    return {
+      diff: row.diff_text || '',
+      stats: row.stats ? JSON.parse(row.stats) : {},
+      digest: row.digest || null
+    };
+  }
+
+  /**
+   * Delete a local review session and all associated data.
+   * Only deletes DB records; does NOT remove files on disk.
+   *
+   * Because the schema uses ON DELETE CASCADE for foreign keys on local_diffs,
+   * comments, and analysis_runs, deleting the review row cascades automatically.
+   *
+   * @param {number} reviewId - Review ID
+   * @returns {Promise<boolean>} True if a record was deleted
+   */
+  async deleteLocalSession(reviewId) {
+    const result = await run(this.db, `
+      DELETE FROM reviews WHERE id = ? AND review_type = 'local'
+    `, [reviewId]);
+    return result.changes > 0;
+  }
 }
 
 /**

package/src/local-review.js

@@ -5,6 +5,7 @@ const crypto = require('crypto');
 const path = require('path');
 const fs = require('fs').promises;
 const { loadConfig, showWelcomeMessage } = require('./config');
+const logger = require('./utils/logger');
 
 const execAsync = promisify(exec);
 const { initializeDatabase, ReviewRepository, RepoSettingsRepository } = require('./database');
@@ -594,6 +595,14 @@ async function handleLocalReview(targetPath, flags = {}) {
     // Store diff data in module-level Map (avoids process.env size limits and security concerns)
     localReviewDiffs.set(sessionId, { diff, stats, digest });
 
+    // Persist diff to database so past sessions remain viewable without the server running
+    try {
+      const reviewRepo = new ReviewRepository(db);
+      await reviewRepo.saveLocalDiff(sessionId, { diff, stats, digest });
+    } catch (persistError) {
+      logger.warn(`Could not persist diff to database: ${persistError.message}`);
+    }
+
     // Set model override if provided
     if (flags.model) {
       process.env.PAIR_REVIEW_MODEL = flags.model;