@covibes/zeroshot 5.2.1 → 5.4.0

package/src/issue-providers/index.js

@@ -0,0 +1,196 @@
+/**
+ * Issue Provider Registry
+ *
+ * Manages issue provider registration and auto-detection
+ */
+
+const GitHubProvider = require('./github-provider');
+const GitLabProvider = require('./gitlab-provider');
+const JiraProvider = require('./jira-provider');
+const AzureDevOpsProvider = require('./azure-devops-provider');
+const { detectGitContext } = require('../../lib/git-remote-utils');
+
+/** @type {Map<string, typeof IssueProvider>} */
+const providers = new Map();
+
+/**
+ * Register a provider class
+ * @param {typeof IssueProvider} ProviderClass
+ */
+function registerProvider(ProviderClass) {
+  if (!ProviderClass.id) {
+    throw new Error(`Provider ${ProviderClass.name} must define static id property`);
+  }
+  providers.set(ProviderClass.id, ProviderClass);
+}
+
+/**
+ * Detect which provider matches the input
+ * Automatically detects provider from git remote when in a git repository
+ *
+ * @param {string} input - User input (URL, issue key, number)
+ * @param {Object} settings - User settings
+ * @param {string|null} forceProvider - Force specific provider (from CLI flag)
+ * @param {Object|null|undefined} [gitContextOverride] - Override git context (for testing)
+ *   - undefined: auto-detect from git remote (default)
+ *   - null: explicitly no git context
+ *   - object: use provided git context
+ * @returns {typeof IssueProvider|null}
+ */
+function detectProvider(input, settings, forceProvider = null, gitContextOverride = undefined) {
+  // Force flag takes precedence
+  if (forceProvider) {
+    return providers.get(forceProvider) || null;
+  }
+
+  // Use provided gitContext or auto-detect
+  const gitContext = gitContextOverride === undefined ? detectGitContext() : gitContextOverride;
+
+  // Auto-detect by checking each provider's detectIdentifier
+  for (const ProviderClass of providers.values()) {
+    if (ProviderClass.detectIdentifier(input, settings, gitContext)) {
+      return ProviderClass;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Get provider class by ID
+ * @param {string} providerId - Provider identifier
+ * @returns {typeof IssueProvider|null}
+ */
+function getProvider(providerId) {
+  return providers.get(providerId) || null;
+}
+
+/**
+ * List all registered provider IDs
+ * @returns {string[]}
+ */
+function listProviders() {
+  return Array.from(providers.keys());
+}
+
+/**
+ * List providers that support PR/MR creation
+ * @returns {string[]}
+ */
+function listPRProviders() {
+  return Array.from(providers.values())
+    .filter((p) => p.supportsPR())
+    .map((p) => p.id);
+}
+
+/**
+ * Determine which git platform to create PR/MR on.
+ * ALWAYS uses git remote context, NEVER the issue provider.
+ *
+ * This is the unified replacement for platform-detector.js
+ *
+ * @param {string} [cwd=process.cwd()] - Working directory
+ * @returns {string} Platform ID ('github', 'gitlab', 'azure-devops')
+ * @throws {Error} If platform cannot be determined or doesn't support PRs
+ *
+ * @example
+ * // In a GitHub repo
+ * getPlatformForPR() // → 'github'
+ *
+ * @example
+ * // In a GitLab repo with Jira issue
+ * getPlatformForPR() // → 'gitlab' (creates GitLab MR, not related to Jira)
+ */
+function getPlatformForPR(cwd = process.cwd()) {
+  const gitContext = detectGitContext(cwd);
+
+  if (!gitContext?.provider) {
+    throw new Error(
+      'Cannot determine git platform for --pr mode. ' +
+        'Ensure you are in a git repository with a remote URL from GitHub, GitLab, or Azure DevOps.'
+    );
+  }
+
+  const platform = gitContext.provider;
+  const ProviderClass = providers.get(platform);
+
+  if (!ProviderClass || !ProviderClass.supportsPR()) {
+    const supported = listPRProviders().join(', ');
+    throw new Error(
+      `Platform '${platform}' does not support --pr mode. Supported platforms: ${supported}`
+    );
+  }
+
+  return platform;
+}
+
+/**
+ * Get PR tool info for a platform
+ * @param {string} platform - Platform ID
+ * @returns {{ name: string, checkCmd: string, installHint: string, displayName: string }|null}
+ */
+function getPRToolForPlatform(platform) {
+  const ProviderClass = providers.get(platform);
+  return ProviderClass?.getPRTool() || null;
+}
+
+/**
+ * Get aggregated settings schema from all issue providers
+ * @returns {Object.<string, Object>} Combined settings schema
+ */
+function getIssueProviderSettingsSchema() {
+  const schema = {};
+  for (const ProviderClass of providers.values()) {
+    Object.assign(schema, ProviderClass.getSettingsSchema());
+  }
+  return schema;
+}
+
+/**
+ * Get default values for all issue provider settings
+ * @returns {Object.<string, any>} Default values keyed by setting name
+ */
+function getIssueProviderSettingsDefaults() {
+  const defaults = {};
+  const schema = getIssueProviderSettingsSchema();
+  for (const [key, config] of Object.entries(schema)) {
+    defaults[key] = config.default;
+  }
+  return defaults;
+}
+
+/**
+ * Validate an issue provider setting
+ * Delegates to the appropriate provider's validateSetting method
+ * @param {string} key - Setting key
+ * @param {any} value - Setting value
+ * @returns {string|null|undefined} Error message if invalid, null if valid, undefined if not an issue provider setting
+ */
+function validateIssueProviderSetting(key, value) {
+  for (const ProviderClass of providers.values()) {
+    const result = ProviderClass.validateSetting(key, value);
+    if (result !== undefined) {
+      return result;
+    }
+  }
+  return undefined; // Not an issue provider setting
+}
+
+// Auto-register providers on module load
+registerProvider(GitHubProvider);
+registerProvider(GitLabProvider);
+registerProvider(JiraProvider);
+registerProvider(AzureDevOpsProvider);
+
+module.exports = {
+  registerProvider,
+  detectProvider,
+  getProvider,
+  listProviders,
+  listPRProviders,
+  getPlatformForPR,
+  getPRToolForPlatform,
+  getIssueProviderSettingsSchema,
+  getIssueProviderSettingsDefaults,
+  validateIssueProviderSetting,
+};

package/src/issue-providers/jira-provider.js

@@ -0,0 +1,239 @@
+/**
+ * Jira Provider - Fetch issues from Jira via jira CLI (go-jira)
+ * Supports both Jira Cloud (*.atlassian.net) and self-hosted (Server/Data Center)
+ */
+
+const IssueProvider = require('./base-provider');
+const { execSync } = require('../lib/safe-exec');
+
+class JiraProvider extends IssueProvider {
+  static id = 'jira';
+  static displayName = 'Jira';
+
+  /**
+   * Detect Jira issue keys and URLs
+   * Matches:
+   * - Jira Cloud URLs (*.atlassian.net)
+   * - Self-hosted Jira URLs (via jiraInstance setting)
+   * - Jira issue keys (KEY-123 format)
+   * - Bare numbers when defaultIssueSource=jira (requires jiraProject setting)
+   *
+   * Note: Jira doesn't use git context since it's not a git hosting platform.
+   * Git context will never match 'jira', so this provider only activates via
+   * explicit Jira URLs, Jira issue keys, or settings.
+   *
+   * @param {string} input - Issue identifier (URL, key, or number)
+   * @param {Object} settings - User settings
+   * @param {Object|null} gitContext - Git context (unused for Jira, but kept for API consistency)
+   * @returns {boolean} True if this provider should handle the input
+   */
+  static detectIdentifier(input, settings, gitContext = null) {
+    // Jira Cloud URLs
+    if (/atlassian\.net\/browse\/[A-Z][A-Z0-9]+-\d+/.test(input)) {
+      return true;
+    }
+
+    // Self-hosted Jira URLs
+    if (
+      settings.jiraInstance &&
+      input.includes(settings.jiraInstance) &&
+      /\/browse\/[A-Z][A-Z0-9]+-\d+/.test(input)
+    ) {
+      return true;
+    }
+
+    // Jira issue key pattern (KEY-123)
+    if (/^[A-Z][A-Z0-9]+-\d+$/.test(input)) {
+      return true;
+    }
+
+    // Bare numbers - use shared priority cascade logic
+    // Jira requires jiraProject setting to convert bare numbers to issue keys
+    // Note: gitContext check will never match 'jira' since Jira isn't a git host
+    return IssueProvider.detectBareNumber(input, settings, gitContext, 'jira', {
+      requiredSettings: ['jiraProject'],
+    });
+  }
+
+  static getRequiredTool() {
+    return {
+      name: 'jira',
+      checkCmd: 'jira version',
+      installHint: 'Install jira-cli: brew install go-jira (or https://github.com/go-jira/jira)',
+    };
+  }
+
+  /**
+   * Check jira CLI authentication
+   * go-jira uses config files (~/.jira.d/) rather than explicit auth commands
+   */
+  static checkAuth() {
+    try {
+      // go-jira uses 'jira session' to verify authentication
+      // If not configured, it fails with endpoint/login errors
+      execSync('jira session', { encoding: 'utf8', stdio: 'pipe', timeout: 5000 });
+      return { authenticated: true, error: null, recovery: [] };
+    } catch (err) {
+      const stderr = err.stderr || err.message || '';
+
+      // go-jira has various error patterns for auth issues
+      if (
+        stderr.includes('endpoint') ||
+        stderr.includes('login') ||
+        stderr.includes('authentication') ||
+        stderr.includes('401')
+      ) {
+        return {
+          authenticated: false,
+          error: 'Jira CLI not configured',
+          recovery: [
+            'Create ~/.jira.d/config.yml with your Jira endpoint',
+            'See: https://github.com/go-jira/jira#configuration',
+            'Example config:\n   endpoint: https://yourcompany.atlassian.net\n   login: your-email@company.com',
+            'Then verify: jira session',
+          ],
+        };
+      }
+
+      // If command just doesn't exist or times out, it's likely not configured
+      if (stderr.includes('command not found') || stderr.includes('ETIMEDOUT')) {
+        return {
+          authenticated: false,
+          error: 'Jira CLI not configured',
+          recovery: [
+            'Configure ~/.jira.d/config.yml',
+            'See: https://github.com/go-jira/jira#configuration',
+          ],
+        };
+      }
+
+      // Default: assume not authenticated
+      return {
+        authenticated: false,
+        error: stderr.trim() || 'Jira CLI not configured or authentication failed',
+        recovery: [
+          'Create ~/.jira.d/config.yml with your Jira endpoint',
+          'See: https://github.com/go-jira/jira#configuration',
+        ],
+      };
+    }
+  }
+
+  /**
+   * Jira-specific settings schema
+   */
+  static getSettingsSchema() {
+    return {
+      jiraInstance: {
+        type: 'string',
+        nullable: true,
+        default: null,
+        description: "Self-hosted Jira URL (e.g., 'jira.company.com')",
+      },
+      jiraProject: {
+        type: 'string',
+        nullable: true,
+        default: null,
+        description: "Default Jira project key for bare numbers (e.g., 'PROJ')",
+        pattern: /^[A-Z][A-Z0-9]*$/,
+        patternMsg: 'jiraProject must be a valid Jira project key (e.g., PROJ, ABC)',
+      },
+    };
+  }
+
+  fetchIssue(identifier, settings) {
+    try {
+      const issueKey = this._extractIssueKey(identifier, settings);
+
+      // Fetch issue using jira CLI
+      const cmd = `jira issue view ${issueKey} --template json`;
+      const output = execSync(cmd, { encoding: 'utf8' });
+      const issue = JSON.parse(output);
+
+      return this._parseIssue(issue);
+    } catch (error) {
+      throw new Error(`Failed to fetch Jira issue: ${error.message}`);
+    }
+  }
+
+  /**
+   * Extract Jira issue key from URL or return as-is
+   * @private
+   */
+  _extractIssueKey(identifier, settings) {
+    // URL format: https://company.atlassian.net/browse/KEY-123
+    const urlMatch = identifier.match(/\/browse\/([A-Z][A-Z0-9]+-\d+)/);
+    if (urlMatch) {
+      return urlMatch[1];
+    }
+
+    // Bare number: construct from jiraProject setting
+    if (/^\d+$/.test(identifier) && settings.jiraProject) {
+      return `${settings.jiraProject}-${identifier}`;
+    }
+
+    // Assume it's already a key
+    return identifier;
+  }
+
+  /**
+   * Parse Jira issue into standardized InputData format
+   * @private
+   */
+  _parseIssue(issue) {
+    const fields = issue.fields || {};
+    const key = issue.key;
+    const summary = fields.summary || '';
+    const description = fields.description || '';
+    const labels = fields.labels || [];
+    const comments = fields.comment?.comments || [];
+
+    let context = `# Jira Issue ${key}\n\n`;
+    context += `## Title\n${summary}\n\n`;
+
+    if (description) {
+      context += `## Description\n${description}\n\n`;
+    }
+
+    if (labels.length > 0) {
+      context += `## Labels\n`;
+      context += labels.map((l) => `- ${l}`).join('\n');
+      context += '\n\n';
+    }
+
+    if (comments.length > 0) {
+      context += `## Comments\n\n`;
+      for (const comment of comments) {
+        const author = comment.author?.displayName || comment.author?.name || 'unknown';
+        context += `### ${author} (${comment.created})\n`;
+        context += `${comment.body}\n\n`;
+      }
+    }
+
+    // Map Jira labels to GitHub format
+    const mappedLabels = labels.map((name) => ({ name }));
+
+    // Map Jira comments to GitHub format
+    const mappedComments = comments.map((comment) => ({
+      author: { login: comment.author?.displayName || comment.author?.name || 'unknown' },
+      createdAt: comment.created,
+      body: comment.body,
+    }));
+
+    // Extract issue number from key (KEY-123 → 123)
+    const numberMatch = key.match(/-(\d+)$/);
+    const number = numberMatch ? parseInt(numberMatch[1], 10) : null;
+
+    return {
+      number,
+      title: summary,
+      body: description,
+      labels: mappedLabels,
+      comments: mappedComments,
+      url: fields.self || null,
+      context,
+    };
+  }
+}
+
+module.exports = JiraProvider;

package/src/ledger.js

@@ -15,20 +15,38 @@ const crypto = require('crypto');
 class Ledger extends EventEmitter {
   constructor(dbPath = ':memory:') {
     super();
-    this.db = new Database(dbPath);
+    this.dbPath = dbPath;
+    const busyTimeoutMs = (() => {
+      const raw = process.env.ZEROSHOT_SQLITE_BUSY_TIMEOUT_MS;
+      if (!raw) return 5000;
+      const value = Number(raw);
+      return Number.isFinite(value) && value >= 0 ? value : 5000;
+    })();
+
+    this.db = new Database(dbPath, { timeout: busyTimeoutMs });
     this.cache = new Map(); // LRU cache for queries
     this.cacheLimit = 1000;
     this._closed = false; // Track closed state to prevent write-after-close
+    this._lastTimestamp = 0;
     this._initSchema();
   }
 
   _initSchema() {
-    // Enable WAL mode for concurrent reads
-    this.db.pragma('journal_mode = WAL');
+    const journalMode = (process.env.ZEROSHOT_SQLITE_JOURNAL_MODE || 'WAL').trim().toUpperCase();
+    // Enable WAL mode for concurrent reads (default), but allow overrides for network filesystems.
+    this.db.pragma(`journal_mode = ${journalMode}`);
     // Force synchronous writes so other processes see changes immediately
     this.db.pragma('synchronous = NORMAL');
-    // Checkpoint WAL frequently for cross-process visibility
-    this.db.pragma('wal_autocheckpoint = 1');
+    // Autocheckpoint trades latency for WAL growth; 1-page checkpoints are extremely slow on
+    // higher-latency disks (common in Kubernetes PVs). Default to SQLite-ish behavior (1000 pages),
+    // but allow override for niche correctness/debugging needs.
+    const walAutocheckpointPages = (() => {
+      const raw = process.env.ZEROSHOT_SQLITE_WAL_AUTOCHECKPOINT_PAGES;
+      if (!raw) return 1000;
+      const value = Number(raw);
+      return Number.isFinite(value) && value >= 0 ? Math.floor(value) : 1000;
+    })();
+    this.db.pragma(`wal_autocheckpoint = ${walAutocheckpointPages}`);
 
     // Create messages table
     this.db.exec(`
@@ -52,6 +70,7 @@ class Ledger extends EventEmitter {
     `);
 
     this._prepareStatements();
+    this._loadLastTimestamp();
   }
 
   _prepareStatements() {
@@ -69,6 +88,13 @@ class Ledger extends EventEmitter {
     };
   }
 
+  _loadLastTimestamp() {
+    const row = this.db.prepare('SELECT MAX(timestamp) AS max_timestamp FROM messages').get();
+    if (row && Number.isFinite(row.max_timestamp)) {
+      this._lastTimestamp = row.max_timestamp;
+    }
+  }
+
   /**
    * Append a message to the ledger
    * @param {Object} message - Message object
@@ -83,7 +109,10 @@ class Ledger extends EventEmitter {
     }
 
     const id = message.id || `msg_${crypto.randomBytes(16).toString('hex')}`;
-    const timestamp = message.timestamp || Date.now();
+    const baseTimestamp = Math.max(Date.now(), this._lastTimestamp + 1);
+    const requestedTimestamp = typeof message.timestamp === 'number' ? message.timestamp : null;
+    const timestamp =
+      requestedTimestamp !== null ? Math.max(requestedTimestamp, baseTimestamp) : baseTimestamp;
 
     const record = {
       id,
@@ -113,6 +142,8 @@ class Ledger extends EventEmitter {
       // Invalidate cache
       this.cache.clear();
 
+      this._lastTimestamp = Math.max(this._lastTimestamp, timestamp);
+
       // Emit event for subscriptions
       const fullMessage = this._deserializeMessage(record);
       this.emit('message', fullMessage);
@@ -149,13 +180,13 @@ class Ledger extends EventEmitter {
     // Create transaction function - all inserts happen atomically
     const insertMany = this.db.transaction((msgs) => {
       const results = [];
-      const baseTimestamp = Date.now();
+      const baseTimestamp = Math.max(Date.now(), this._lastTimestamp + 1);
 
       for (let i = 0; i < msgs.length; i++) {
         const message = msgs[i];
         const id = message.id || `msg_${crypto.randomBytes(16).toString('hex')}`;
         // Use incrementing timestamps to preserve order within batch
-        const timestamp = message.timestamp || (baseTimestamp + i);
+        const timestamp = baseTimestamp + i;
 
         const record = {
           id,
@@ -184,16 +215,18 @@ class Ledger extends EventEmitter {
         results.push(this._deserializeMessage(record));
       }
 
-      return results;
+      return { results, baseTimestamp };
     });
 
     try {
       // Execute transaction (atomic - all or nothing)
-      const appendedMessages = insertMany(messages);
+      const { results: appendedMessages, baseTimestamp } = insertMany(messages);
 
       // Invalidate cache
       this.cache.clear();
 
+      this._lastTimestamp = Math.max(this._lastTimestamp, baseTimestamp + messages.length - 1);
+
       // Emit events for subscriptions AFTER transaction commits
       // This ensures listeners see consistent state
       for (const fullMessage of appendedMessages) {
@@ -248,7 +281,13 @@ class Ledger extends EventEmitter {
       params.push(typeof until === 'number' ? until : new Date(until).getTime());
     }
 
-    let sql = `SELECT * FROM messages WHERE ${conditions.join(' AND ')} ORDER BY timestamp ASC`;
+    // Defend against prototype pollution affecting default query ordering.
+    // Only treat `criteria.order` as set if it's an own property.
+    const orderValue = Object.prototype.hasOwnProperty.call(criteria, 'order')
+      ? criteria.order
+      : undefined;
+    const direction = String(orderValue ?? 'asc').toLowerCase() === 'desc' ? 'DESC' : 'ASC';
+    let sql = `SELECT * FROM messages WHERE ${conditions.join(' AND ')} ORDER BY timestamp ${direction}`;
 
     if (limit) {
       sql += ` LIMIT ?`;

package/src/lib/safe-exec.js

@@ -0,0 +1,88 @@
+/**
+ * Safe subprocess execution with mandatory timeouts.
+ *
+ * NEVER use child_process.exec() or execSync() directly.
+ * These wrappers enforce timeouts to prevent infinite hangs.
+ */
+
+const { exec: nodeExec, execSync: nodeExecSync } = require('child_process');
+
+/** Default timeout: 30 seconds */
+const DEFAULT_TIMEOUT_MS = 30000;
+
+/**
+ * Execute command with mandatory timeout.
+ * Supports both Promise and callback styles for gradual migration.
+ *
+ * @param {string} command - Command to execute
+ * @param {object} [options] - Options (timeout uses default if not specified)
+ * @param {function} [callback] - Optional callback(error, stdout, stderr)
+ * @returns {Promise<{stdout: string, stderr: string}>|void} Promise if no callback, void if callback
+ *
+ * @example
+ * // Promise style (preferred)
+ * const { stdout } = await exec('ls -la', { timeout: 5000 });
+ *
+ * @example
+ * // Callback style (for legacy code migration)
+ * exec('ls -la', { timeout: 5000 }, (error, stdout) => { ... });
+ */
+function exec(command, optionsOrCallback = {}, callbackArg = null) {
+  // Handle overloaded signature: exec(cmd, callback)
+  const callback = typeof optionsOrCallback === 'function' ? optionsOrCallback : callbackArg;
+  const options = typeof optionsOrCallback === 'function' ? {} : optionsOrCallback;
+
+  const timeout = options.timeout ?? DEFAULT_TIMEOUT_MS;
+
+  if (timeout <= 0) {
+    const err = new Error('exec() timeout must be > 0. Infinite waits are forbidden.');
+    if (callback) {
+      callback(err);
+      return;
+    }
+    return Promise.reject(err);
+  }
+
+  // Callback style
+  if (callback) {
+    nodeExec(command, { ...options, timeout }, (error, stdout, stderr) => {
+      if (error && error.killed && error.signal === 'SIGTERM') {
+        error.message = `Command timed out after ${timeout}ms: ${command}`;
+      }
+      callback(error, stdout, stderr);
+    });
+    return;
+  }
+
+  // Promise style
+  return new Promise((resolve, reject) => {
+    nodeExec(command, { ...options, timeout }, (error, stdout, stderr) => {
+      if (error) {
+        if (error.killed && error.signal === 'SIGTERM') {
+          error.message = `Command timed out after ${timeout}ms: ${command}`;
+        }
+        reject(error);
+      } else {
+        resolve({ stdout, stderr });
+      }
+    });
+  });
+}
+
+/**
+ * Execute command with mandatory timeout (sync)
+ * @param {string} command - Command to execute
+ * @param {object} [options] - Options (timeout required or uses default)
+ * @returns {string} stdout
+ */
+function execSync(command, options = {}) {
+  const timeout = options.timeout ?? DEFAULT_TIMEOUT_MS;
+
+  if (timeout <= 0) {
+    throw new Error('execSync() timeout must be > 0. Infinite waits are forbidden.');
+  }
+
+  return nodeExecSync(command, { ...options, timeout });
+}
+
+module.exports = { exec, execSync, DEFAULT_TIMEOUT_MS };