@agile-vibe-coding/avc 0.1.1 → 0.3.1

package/cli/llm-xiaomi.js

@@ -0,0 +1,143 @@
+/**
+ * llm-xiaomi.js — Xiaomi MiMo LLM provider.
+ *
+ * Uses the OpenAI-compatible API at https://api.xiaomimimo.com/v1.
+ * Supports: mimo-v2-flash, mimo-v2-pro, mimo-v2-omni.
+ *
+ * Requires XIAOMI_API_KEY environment variable.
+ */
+
+import OpenAI from 'openai';
+import { LLMProvider } from './llm-provider.js';
+
+const XIAOMI_BASE_URL = 'https://api.xiaomimimo.com/v1';
+
+function cleanResponse(text) {
+  if (!text) return '';
+  // Strip markdown code fences
+  return text.replace(/^```(?:json)?\s*\n?/i, '').replace(/\n?```\s*$/i, '').trim();
+}
+
+function extractJSON(text) {
+  // Try to find JSON object or array in the response
+  const jsonMatch = text.match(/(\{[\s\S]*\}|\[[\s\S]*\])/);
+  return jsonMatch ? jsonMatch[1] : text;
+}
+
+export class XiaomiProvider extends LLMProvider {
+  constructor(model) {
+    super('xiaomi', model || 'mimo-v2-flash');
+  }
+
+  _createClient() {
+    const apiKey = process.env.XIAOMI_API_KEY;
+    if (!apiKey) {
+      throw new Error('XIAOMI_API_KEY not set. Add it to your .env file. Get a key at https://platform.xiaomimimo.com/#/console/api-keys');
+    }
+    return new OpenAI({
+      apiKey,
+      baseURL: XIAOMI_BASE_URL,
+      timeout: 10 * 60_000, // 10 min
+      maxRetries: 0,
+    });
+  }
+
+  async _callProvider(prompt, maxTokens, systemInstructions) {
+    if (!this._client) this._client = this._createClient();
+
+    const messages = [];
+    if (systemInstructions) {
+      messages.push({ role: 'system', content: systemInstructions });
+    }
+    messages.push({ role: 'user', content: prompt });
+
+    const response = await this._client.chat.completions.create({
+      model: this.model,
+      messages,
+      max_tokens: maxTokens,
+    });
+
+    const usage = response.usage;
+    this._trackTokens(usage, { prompt, agentInstructions: systemInstructions, response: response.choices?.[0]?.message?.content });
+
+    return response.choices?.[0]?.message?.content || '';
+  }
+
+  async generateJSON(prompt, agentInstructions = null, cachedContext = null) {
+    if (!this._client) this._client = this._createClient();
+
+    const JSON_SYSTEM = 'You are a helpful assistant that always returns valid JSON. Your response must be a valid JSON object or array, nothing else. Do not include any thinking, reasoning, or explanation — only the JSON.';
+    const systemParts = [JSON_SYSTEM];
+    if (agentInstructions) systemParts.push(agentInstructions);
+    if (cachedContext) systemParts.push(`---\n\n${cachedContext}`);
+
+    const messages = [
+      { role: 'system', content: systemParts.join('\n\n') },
+      { role: 'user', content: prompt },
+    ];
+
+    const _t0 = Date.now();
+    const response = await this._withRetry(
+      () => this._client.chat.completions.create({
+        model: this.model,
+        messages,
+        response_format: { type: 'json_object' },
+      }),
+      'JSON generation (Xiaomi)'
+    );
+
+    const content = response.choices?.[0]?.message?.content || '';
+    this._trackTokens(response.usage, {
+      prompt,
+      agentInstructions: agentInstructions ?? null,
+      response: content,
+      elapsed: Date.now() - _t0,
+    });
+
+    const jsonStr = extractJSON(cleanResponse(content));
+    try {
+      return JSON.parse(jsonStr);
+    } catch (firstError) {
+      // Try jsonrepair as fallback
+      try {
+        const { jsonrepair } = await import('jsonrepair');
+        return JSON.parse(jsonrepair(jsonStr));
+      } catch {
+        throw new Error(`Failed to parse JSON from Xiaomi (${this.model}): ${firstError.message}\n\nResponse:\n${content.slice(0, 500)}`);
+      }
+    }
+  }
+
+  async generateText(prompt, agentInstructions = null, cachedContext = null) {
+    if (!this._client) this._client = this._createClient();
+
+    const systemParts = [];
+    if (agentInstructions) systemParts.push(agentInstructions);
+    if (cachedContext) systemParts.push(cachedContext);
+
+    const messages = [];
+    if (systemParts.length > 0) {
+      messages.push({ role: 'system', content: systemParts.join('\n\n') });
+    }
+    messages.push({ role: 'user', content: prompt });
+
+    const _t0 = Date.now();
+    const response = await this._withRetry(
+      () => this._client.chat.completions.create({
+        model: this.model,
+        messages,
+      }),
+      'Text generation (Xiaomi)'
+    );
+
+    const content = response.choices?.[0]?.message?.content || '';
+    this._trackTokens(response.usage, {
+      prompt,
+      agentInstructions: agentInstructions ?? null,
+      response: content,
+      elapsed: Date.now() - _t0,
+    });
+
+    return content;
+  }
+}

package/cli/message-constants.js

@@ -0,0 +1,49 @@
+/**
+ * Message Constants - Reusable message definitions
+ *
+ * Centralized message strings to prevent duplication and ensure consistency.
+ * Use these constants instead of hardcoded strings throughout the codebase.
+ */
+
+/**
+ * Common error messages
+ */
+export const MESSAGES = {
+  /**
+   * Project not initialized error
+   */
+  PROJECT_NOT_INITIALIZED: {
+    error: 'Project not initialized',
+    help: 'Please run /init first to create the project structure.'
+  },
+
+  /**
+   * Ceremony headers with titles and documentation URLs
+   */
+  CEREMONY_HEADERS: {
+    'sponsor-call':   { title: 'Sponsor Call Ceremony' },
+    'sprint-planning': { title: 'Sprint Planning Ceremony' },
+    'seed':           { title: 'Seed Ceremony' },
+  }
+};
+
+/**
+ * Helper function to get full "project not initialized" error message
+ * @returns {string} Complete error message with help text
+ */
+export function getProjectNotInitializedMessage() {
+  return `${MESSAGES.PROJECT_NOT_INITIALIZED.error}\n\n${MESSAGES.PROJECT_NOT_INITIALIZED.help}`;
+}
+
+/**
+ * Helper function to get ceremony header
+ * @param {string} ceremonyName - Name of ceremony ('sponsor-call', 'sprint-planning', 'seed')
+ * @returns {object} Object with title and url properties
+ */
+export function getCeremonyHeader(ceremonyName) {
+  const header = MESSAGES.CEREMONY_HEADERS[ceremonyName];
+  if (!header) {
+    throw new Error(`Unknown ceremony: ${ceremonyName}`);
+  }
+  return header;
+}

package/cli/message-manager.js

@@ -0,0 +1,334 @@
+/**
+ * MessageManager - Centralized message handling system
+ *
+ * Singleton that manages all console output through execution contexts.
+ * Prevents ghost messages by tracking command lifecycle and cancelling
+ * messages from previous runs.
+ */
+
+import { MessageType } from './message-types.js';
+import { ExecutionContext } from './execution-context.js';
+import { outputBuffer } from './output-buffer.js';
+
+/**
+ * MessageManager singleton class
+ */
+class MessageManager {
+  constructor() {
+    if (MessageManager.instance) {
+      return MessageManager.instance;
+    }
+
+    this.currentContext = null;
+    this.contextHistory = [];
+    this.maxHistorySize = 10;
+    this.executingMessageCallback = null;
+    this.executingSubstepCallback = null;
+
+    MessageManager.instance = this;
+  }
+
+  /**
+   * Set executing message callback (from React state setter)
+   * @param {Function} callback - setExecutingMessage function
+   */
+  setExecutingMessageCallback(callback) {
+    this.executingMessageCallback = callback;
+  }
+
+  /**
+   * Set executing substep callback (from React state setter)
+   * @param {Function} callback - setExecutingSubstep function
+   */
+  setExecutingSubstepCallback(callback) {
+    this.executingSubstepCallback = callback;
+  }
+
+  /**
+   * Start a new execution context for a command
+   * @param {string} commandName - Name of the command
+   * @returns {ExecutionContext} New execution context
+   */
+  startExecution(commandName) {
+    // Cancel previous context if active
+    if (this.currentContext && this.currentContext.isActive()) {
+      this.currentContext.cancel();
+    }
+
+    // Create new context
+    this.currentContext = new ExecutionContext(commandName);
+
+    // Add to history
+    this.contextHistory.push(this.currentContext);
+    if (this.contextHistory.length > this.maxHistorySize) {
+      this.contextHistory.shift();
+    }
+
+    // Insert visual separator between commands in the Static output
+    outputBuffer.clear();
+
+    return this.currentContext;
+  }
+
+  /**
+   * End the current execution context
+   */
+  endExecution() {
+    if (this.currentContext) {
+      this.currentContext.complete();
+      this.currentContext = null;
+    }
+
+    // Clear progress indicators
+    if (this.executingMessageCallback) {
+      this.executingMessageCallback('');
+    }
+    if (this.executingSubstepCallback) {
+      this.executingSubstepCallback('');
+    }
+  }
+
+  /**
+   * Cancel the current execution context
+   */
+  cancelExecution() {
+    if (this.currentContext) {
+      this.currentContext.cancel();
+      this.currentContext = null;
+    }
+
+    // Clear progress indicators
+    if (this.executingMessageCallback) {
+      this.executingMessageCallback('');
+    }
+    if (this.executingSubstepCallback) {
+      this.executingSubstepCallback('');
+    }
+  }
+
+  /**
+   * Get current execution context
+   * @returns {ExecutionContext|null} Current context or null
+   */
+  getCurrentContext() {
+    return this.currentContext;
+  }
+
+  /**
+   * Send a message through the current context
+   * @param {string} type - MessageType
+   * @param {string} content - Message content
+   * @param {Object} options - Additional options
+   */
+  send(type, content, options = {}) {
+    // Validate message type
+    if (!Object.values(MessageType).includes(type)) {
+      console.error(`Invalid message type: ${type}`);
+      return;
+    }
+
+    // Ignore if no active context
+    if (!this.currentContext || !this.currentContext.isActive()) {
+      return;
+    }
+
+    // Handle different message types
+    switch (type) {
+      case MessageType.COMMAND_START:
+        this._handleCommandStart(content);
+        break;
+
+      case MessageType.CEREMONY_HEADER:
+        this._handleCeremonyHeader(content);
+        break;
+
+      case MessageType.PROGRESS:
+        this._handleProgress(content);
+        break;
+
+      case MessageType.SUBSTEP:
+        this._handleSubstep(content);
+        break;
+
+      case MessageType.USER_OUTPUT:
+        this._handleUserOutput(content);
+        break;
+
+      case MessageType.ERROR:
+        this._handleError(content);
+        break;
+
+      case MessageType.WARNING:
+        this._handleWarning(content);
+        break;
+
+      case MessageType.SUCCESS:
+        this._handleSuccess(content);
+        break;
+
+      case MessageType.INFO:
+        this._handleInfo(content);
+        break;
+
+      case MessageType.DEBUG:
+        this._handleDebug(content, options);
+        break;
+
+      default:
+        this._handleUserOutput(content);
+    }
+  }
+
+  /**
+   * Handle COMMAND_START message
+   * @private
+   */
+  _handleCommandStart(content) {
+    // Clear output buffer (already done in startExecution)
+    // This is a marker message type, no output needed
+  }
+
+  /**
+   * Handle CEREMONY_HEADER message
+   * @private
+   */
+  _handleCeremonyHeader(content) {
+    outputBuffer.append(content);
+  }
+
+  /**
+   * Handle PROGRESS message
+   * @private
+   */
+  _handleProgress(content) {
+    if (this.currentContext) {
+      this.currentContext.setExecutingMessage(content);
+    }
+    if (this.executingMessageCallback) {
+      this.executingMessageCallback(content);
+    }
+  }
+
+  /**
+   * Handle SUBSTEP message
+   * @private
+   */
+  _handleSubstep(content) {
+    if (this.currentContext) {
+      this.currentContext.setExecutingSubstep(content);
+    }
+    if (this.executingSubstepCallback) {
+      this.executingSubstepCallback(content);
+    }
+  }
+
+  /**
+   * Handle USER_OUTPUT message
+   * @private
+   */
+  _handleUserOutput(content) {
+    // Empty string means "blank line" — outputBuffer ignores falsy values,
+    // so convert '' to '\n' to produce the intended visual gap.
+    outputBuffer.append(content === '' ? '\n' : content);
+  }
+
+  /**
+   * Handle ERROR message
+   * @private
+   */
+  _handleError(content) {
+    outputBuffer.append(`ERROR: ${content}`, 'ERROR');
+  }
+
+  /**
+   * Handle WARNING message
+   * @private
+   */
+  _handleWarning(content) {
+    outputBuffer.append(`WARNING: ${content}`, 'WARNING');
+  }
+
+  /**
+   * Handle SUCCESS message
+   * @private
+   */
+  _handleSuccess(content) {
+    outputBuffer.append(`SUCCESS: ${content}`, 'SUCCESS');
+  }
+
+  /**
+   * Handle INFO message
+   * @private
+   */
+  _handleInfo(content) {
+    outputBuffer.append(`INFO: ${content}`, 'INFO');
+  }
+
+  /**
+   * Handle DEBUG message
+   * @private
+   */
+  _handleDebug(content, options = {}) {
+    // Debug messages only go to console.log, not main output
+    const timestamp = new Date().toISOString();
+    if (options.data) {
+      console.log(`[DEBUG][${timestamp}] ${content}`, JSON.stringify(options.data, null, 2));
+    } else {
+      console.log(`[DEBUG][${timestamp}] ${content}`);
+    }
+  }
+
+  /**
+   * Clear progress indicators
+   */
+  clearProgress() {
+    if (this.currentContext) {
+      this.currentContext.clearExecutingMessage();
+      this.currentContext.clearExecutingSubstep();
+    }
+    if (this.executingMessageCallback) {
+      this.executingMessageCallback('');
+    }
+    if (this.executingSubstepCallback) {
+      this.executingSubstepCallback('');
+    }
+  }
+
+  /**
+   * Get execution context history
+   * @returns {Array} Array of execution contexts
+   */
+  getHistory() {
+    return [...this.contextHistory];
+  }
+
+  /**
+   * Get manager state for debugging
+   * @returns {Object} Manager state
+   */
+  toJSON() {
+    return {
+      hasCurrentContext: !!this.currentContext,
+      currentContext: this.currentContext ? this.currentContext.toJSON() : null,
+      historySize: this.contextHistory.length,
+      hasCallbacks: {
+        executingMessage: !!this.executingMessageCallback,
+        executingSubstep: !!this.executingSubstepCallback
+      }
+    };
+  }
+
+  /**
+   * Reset manager (for testing)
+   */
+  reset() {
+    if (this.currentContext) {
+      this.currentContext.cancel();
+    }
+    this.currentContext = null;
+    this.contextHistory = [];
+  }
+}
+
+// Export singleton instance
+export const messageManager = new MessageManager();

package/cli/message-types.js

@@ -0,0 +1,96 @@
+/**
+ * Message Types for MessageManager
+ *
+ * Defines different types of messages that can be sent through the messaging system.
+ * Each type can be handled differently (formatting, logging, display).
+ */
+
+export const MessageType = {
+  /**
+   * Command start - marks the beginning of a command execution
+   * Typically clears the output buffer
+   */
+  COMMAND_START: 'COMMAND_START',
+
+  /**
+   * Ceremony header - displays ceremony title and documentation URL
+   * Format: 🎯 Title\n📖 URL
+   */
+  CEREMONY_HEADER: 'CEREMONY_HEADER',
+
+  /**
+   * Progress indicator - shows ongoing operation status
+   * These go to executingMessage state, not main output
+   */
+  PROGRESS: 'PROGRESS',
+
+  /**
+   * Substep progress - shows detailed progress within an operation
+   * These go to executingSubstep state, not main output
+   */
+  SUBSTEP: 'SUBSTEP',
+
+  /**
+   * User output - main content shown to user
+   * Standard output messages
+   */
+  USER_OUTPUT: 'USER_OUTPUT',
+
+  /**
+   * Error message - displays errors to user
+   * Automatically formatted with ERROR: prefix in red bold
+   */
+  ERROR: 'ERROR',
+
+  /**
+   * Warning message - displays warnings to user
+   * Automatically formatted with WARNING: prefix in yellow bold
+   */
+  WARNING: 'WARNING',
+
+  /**
+   * Success message - displays success confirmation
+   * Automatically formatted with SUCCESS: prefix in green bold
+   */
+  SUCCESS: 'SUCCESS',
+
+  /**
+   * Debug message - development/troubleshooting info
+   * Not shown in main output, only console.log
+   */
+  DEBUG: 'DEBUG',
+
+  /**
+   * Info message - informational content
+   * Automatically formatted with INFO: prefix in cyan
+   */
+  INFO: 'INFO'
+};
+
+/**
+ * Check if a message type is valid
+ * @param {string} type - Message type to validate
+ * @returns {boolean} True if valid
+ */
+export function isValidMessageType(type) {
+  return Object.values(MessageType).includes(type);
+}
+
+/**
+ * Get default formatting for a message type
+ * @param {string} type - Message type
+ * @returns {object} Format configuration with prefix, color, and bold flag
+ */
+export function getMessageFormat(type) {
+  const formats = {
+    [MessageType.ERROR]: { prefix: 'ERROR: ', color: 'red', bold: true },
+    [MessageType.WARNING]: { prefix: 'WARNING: ', color: 'yellow', bold: true },
+    [MessageType.SUCCESS]: { prefix: 'SUCCESS: ', color: 'green', bold: true },
+    [MessageType.INFO]: { prefix: 'INFO: ', color: 'cyan', bold: false },
+    [MessageType.CEREMONY_HEADER]: { prefix: '', color: 'cyan', bold: true },
+    [MessageType.USER_OUTPUT]: { prefix: '', color: 'white', bold: false },
+    [MessageType.DEBUG]: { prefix: '[DEBUG] ', color: 'gray', bold: false }
+  };
+
+  return formats[type] || { prefix: '', color: 'white', bold: false };
+}