@agile-vibe-coding/avc 0.2.3 → 0.3.2

package/cli/llm-token-limits.js

@@ -17,6 +17,9 @@
  * - OpenAI: https://community.openai.com/t/what-is-the-token-limit-of-the-new-version-gpt-4o/752528
  */
 
+// Suppress duplicate warnings — each model warned only once per process
+const _warnedModels = new Set();
+
 export const MODEL_MAX_TOKENS = {
   // Claude models (Anthropic)
   // Source: https://docs.cloud.google.com/vertex-ai/generative-ai/docs/partner-models/claude/
@@ -31,8 +34,14 @@ export const MODEL_MAX_TOKENS = {
 
   // OpenAI models
   // Source: https://community.openai.com/t/what-is-the-token-limit-of-the-new-version-gpt-4o/752528
-  'gpt-5.2-chat-latest': 16384,    // Test/future model
-  'gpt-5.2-pro': 16384,
+  // GPT-5 family (32K output tokens assumed; add specific overrides as official limits are confirmed)
+  'gpt-5':         32768,
+  'gpt-5.1':       32768,
+  'gpt-5.2':       32768,
+  'gpt-5.4':       32768,
+  'gpt-5-mini':    32768,
+  'gpt-5.2-chat-latest': 16384,  // Keep at 16384 — existing tests depend on this value
+  'gpt-5.2-pro':   16384,
   'gpt-5.2-codex': 16384,
   'gpt-4o': 16384,                 // Correct - max 16,384 tokens
   'gpt-4o-2024-11-20': 16384,
@@ -58,6 +67,51 @@ export const MODEL_MAX_TOKENS = {
   'default': 8192
 };
 
+/**
+ * Model context window sizes (total input + output tokens)
+ *
+ * These represent the full context window each model supports.
+ * For local models, we use conservative defaults since the actual
+ * model behind the endpoint is unknown.
+ */
+export const MODEL_CONTEXT_WINDOWS = {
+  // Claude models
+  'claude-sonnet-4-5': 200000,
+  'claude-sonnet-4': 200000,
+  'claude-opus-4-6': 200000,
+  'claude-opus-4': 200000,
+  'claude-haiku-4-5': 200000,
+  'claude-haiku-4': 200000,
+
+  // OpenAI models
+  'gpt-5': 128000,
+  'gpt-5.1': 128000,
+  'gpt-5.2': 128000,
+  'gpt-5.4': 128000,
+  'gpt-5-mini': 128000,
+  'gpt-4o': 128000,
+  'gpt-4o-mini': 128000,
+  'gpt-4-turbo': 128000,
+  'gpt-4': 8192,
+
+  // Google Gemini models
+  'gemini-3.1-pro-preview': 1048576,
+  'gemini-3-flash-preview': 1048576,
+  'gemini-2.5-pro': 1048576,
+  'gemini-2.5-flash': 1048576,
+  'gemini-2.0-flash': 1048576,
+  'gemini-1.5-pro': 2097152,
+  'gemini-1.5-flash': 1048576,
+
+  // Default for unknown local models - conservative estimate
+  'local-default': 8192,
+
+  // Xiaomi MiMo models
+  'mimo-v2-flash': 262144,
+  'mimo-v2-pro': 1048576,
+  'mimo-v2-omni': 262144,
+};
+
 /**
  * Get maximum output tokens for a specific model
  * @param {string} modelId - The model identifier
@@ -79,11 +133,62 @@ export function getMaxTokensForModel(modelId) {
     return MODEL_MAX_TOKENS[baseModel];
   }
 
+  // Prefix fallback: catch any gpt-5.x variant not explicitly listed
+  if (modelId.startsWith('gpt-5')) {
+    if (!_warnedModels.has(modelId)) {
+      _warnedModels.add(modelId);
+      console.warn(`No exact max tokens for "${modelId}", using GPT-5 family default: 32768`);
+    }
+    return 32768;
+  }
+
   // Fallback to default
-  console.warn(`No max tokens configured for model "${modelId}", using default: ${MODEL_MAX_TOKENS['default']}`);
+  if (!_warnedModels.has(modelId)) {
+    _warnedModels.add(modelId);
+    console.warn(`No max tokens configured for model "${modelId}", using default: ${MODEL_MAX_TOKENS['default']}`);
+  }
   return MODEL_MAX_TOKENS['default'];
 }
 
+/**
+ * Get the context window size for a specific model
+ * @param {string} modelId - The model identifier
+ * @param {string} provider - The provider name ('claude', 'openai', 'gemini', 'local')
+ * @returns {number|null} Context window size in tokens, or null if no limit enforcement
+ */
+export function getContextWindowForModel(modelId, provider) {
+  // Local provider: use conservative default, overridable via env var
+  if (provider === 'local') {
+    const envOverride = process.env.LOCAL_LLM_CONTEXT_WINDOW;
+    if (envOverride) {
+      const parsed = parseInt(envOverride, 10);
+      if (!isNaN(parsed) && parsed > 0) {
+        return parsed;
+      }
+      console.warn(`Invalid LOCAL_LLM_CONTEXT_WINDOW value "${envOverride}", using default: ${MODEL_CONTEXT_WINDOWS['local-default']}`);
+    }
+    return MODEL_CONTEXT_WINDOWS['local-default'];
+  }
+
+  if (!modelId) {
+    return null;
+  }
+
+  // Direct lookup
+  if (MODEL_CONTEXT_WINDOWS[modelId]) {
+    return MODEL_CONTEXT_WINDOWS[modelId];
+  }
+
+  // Fuzzy match for versioned models (e.g., "claude-opus-4-latest" → "claude-opus-4")
+  const baseModel = modelId.split('-').slice(0, 3).join('-');
+  if (MODEL_CONTEXT_WINDOWS[baseModel]) {
+    return MODEL_CONTEXT_WINDOWS[baseModel];
+  }
+
+  // Unknown cloud model — no limit enforcement
+  return null;
+}
+
 /**
  * Validate if requested tokens exceed model limit
  * @param {string} modelId - The model identifier
@@ -94,7 +199,11 @@ export function clampTokensToModelLimit(modelId, requestedTokens) {
   const maxTokens = getMaxTokensForModel(modelId);
 
   if (requestedTokens > maxTokens) {
-    console.warn(`Requested ${requestedTokens} tokens for ${modelId}, clamping to model limit: ${maxTokens}`);
+    const clampKey = `clamp:${modelId}:${requestedTokens}`;
+    if (!_warnedModels.has(clampKey)) {
+      _warnedModels.add(clampKey);
+      console.warn(`Requested ${requestedTokens} tokens for ${modelId}, clamping to model limit: ${maxTokens}`);
+    }
     return maxTokens;
   }
 

package/cli/llm-verifier.js

@@ -107,6 +107,80 @@ export class LLMVerifier {
     }
   }
 
+  /**
+   * Fast-path: Check if a numeric field is within range
+   */
+  fastPathScoreRange(content, field, min, max) {
+    try {
+      const { unwrapped } = this.unwrapJsonCodeFence(content);
+      const obj = JSON.parse(unwrapped);
+      const val = obj[field];
+      if (typeof val === 'number' && Number.isInteger(val) && val >= min && val <= max) {
+        return { canFastPath: true, violated: false };
+      }
+      return { canFastPath: true, violated: true, reason: `${field}=${val} (expected integer ${min}-${max})` };
+    } catch {
+      return { canFastPath: false };
+    }
+  }
+
+  /**
+   * Fast-path: Check if a field value is one of allowed enum values
+   */
+  fastPathEnum(content, field, allowedValues) {
+    try {
+      const { unwrapped } = this.unwrapJsonCodeFence(content);
+      const obj = JSON.parse(unwrapped);
+      if (allowedValues.includes(obj[field])) {
+        return { canFastPath: true, violated: false };
+      }
+      return { canFastPath: true, violated: true, reason: `${field}="${obj[field]}" not in [${allowedValues.join(',')}]` };
+    } catch {
+      return { canFastPath: false };
+    }
+  }
+
+  /**
+   * Fast-path: Check enum values inside nested objects within arrays
+   */
+  fastPathEnumDeep(content, field, allowedValues, searchArrays) {
+    try {
+      const { unwrapped } = this.unwrapJsonCodeFence(content);
+      const obj = JSON.parse(unwrapped);
+      const invalid = [];
+      for (const arrName of searchArrays) {
+        if (Array.isArray(obj[arrName])) {
+          for (const item of obj[arrName]) {
+            if (item[field] && !allowedValues.includes(item[field])) {
+              invalid.push(`${arrName}.${field}="${item[field]}"`);
+            }
+          }
+        }
+      }
+      if (invalid.length === 0) return { canFastPath: true, violated: false };
+      return { canFastPath: true, violated: true, reason: invalid.join(', ') };
+    } catch {
+      return { canFastPath: false };
+    }
+  }
+
+  /**
+   * Fast-path: Check if specified fields are arrays (not strings/objects/null)
+   */
+  fastPathArrayFields(content, arrayFields) {
+    try {
+      const { unwrapped } = this.unwrapJsonCodeFence(content);
+      const obj = JSON.parse(unwrapped);
+      const nonArrays = arrayFields.filter(f => f in obj && !Array.isArray(obj[f]));
+      if (nonArrays.length === 0) {
+        return { canFastPath: true, violated: false };
+      }
+      return { canFastPath: true, violated: true, reason: `non-array fields: ${nonArrays.join(', ')}` };
+    } catch {
+      return { canFastPath: false };
+    }
+  }
+
   /**
    * Execute fast-path optimization if configured
    * @param {string} content - Content to check
@@ -130,6 +204,19 @@ export class LLMVerifier {
         const fields = rule.fastPath.requiredFields || [];
         return this.fastPathRequiredFields(content, fields);
 
+      case 'json-arrays':
+        // Array fields fast-path — check that specified fields are arrays
+        return this.fastPathArrayFields(content, rule.fastPath.arrayFields || []);
+
+      case 'json-score-range':
+        return this.fastPathScoreRange(content, rule.fastPath.field, rule.fastPath.min, rule.fastPath.max);
+
+      case 'json-enum':
+        return this.fastPathEnum(content, rule.fastPath.field, rule.fastPath.allowedValues || []);
+
+      case 'json-enum-deep':
+        return this.fastPathEnumDeep(content, rule.fastPath.field, rule.fastPath.allowedValues || [], rule.fastPath.searchArrays || []);
+
       case 'none':
       default:
         // No fast-path, use LLM
@@ -228,7 +315,7 @@ export class LLMVerifier {
         this.tracker.startRuleFix(content.length);
       }
 
-      // Fast-path fix if configured
+      // Fast-path fix: unwrap JSON code fences
       if (rule.fastPath?.enabled && rule.fastPath.type === 'json-parse') {
         const { isWrapped, unwrapped } = this.unwrapJsonCodeFence(content);
         if (isWrapped) {
@@ -240,6 +327,127 @@ export class LLMVerifier {
         }
       }
 
+      // Fast-path fix: clamp score to valid range
+      if (rule.fastPath?.enabled && rule.fastPath.type === 'json-score-range') {
+        try {
+          const { unwrapped } = this.unwrapJsonCodeFence(content);
+          const obj = JSON.parse(unwrapped);
+          const { field, min, max } = rule.fastPath;
+          let val = obj[field];
+          if (typeof val !== 'number' || isNaN(val)) val = 50;
+          obj[field] = Math.round(Math.min(max, Math.max(min, val)));
+          const result = JSON.stringify(obj, null, 2);
+          console.log(`[DEBUG] Fast-path fix for ${rule.id}: clamped ${field} to ${obj[field]} (no LLM call)`);
+          if (this.tracker) this.tracker.endRuleFix(result.length);
+          return result;
+        } catch { /* fall through */ }
+      }
+
+      // Fast-path fix: correct enum value based on score
+      if (rule.fastPath?.enabled && rule.fastPath.type === 'json-enum' && rule.fastPath.field === 'validationStatus') {
+        try {
+          const { unwrapped } = this.unwrapJsonCodeFence(content);
+          const obj = JSON.parse(unwrapped);
+          const score = obj.overallScore;
+          if (typeof score === 'number') {
+            obj.validationStatus = score >= 90 ? 'excellent' : score >= 75 ? 'acceptable' : 'needs-improvement';
+          } else {
+            obj.validationStatus = 'needs-improvement';
+          }
+          const result = JSON.stringify(obj, null, 2);
+          console.log(`[DEBUG] Fast-path fix for ${rule.id}: set validationStatus="${obj.validationStatus}" (no LLM call)`);
+          if (this.tracker) this.tracker.endRuleFix(result.length);
+          return result;
+        } catch { /* fall through */ }
+      }
+
+      // Fast-path fix: correct severity enum values in nested arrays
+      if (rule.fastPath?.enabled && rule.fastPath.type === 'json-enum-deep') {
+        try {
+          const { unwrapped } = this.unwrapJsonCodeFence(content);
+          const obj = JSON.parse(unwrapped);
+          const { field, allowedValues, searchArrays } = rule.fastPath;
+          const severityMap = { high: 'critical', medium: 'major', low: 'minor' };
+          for (const arrName of searchArrays) {
+            if (Array.isArray(obj[arrName])) {
+              for (const item of obj[arrName]) {
+                if (item[field] && !allowedValues.includes(item[field])) {
+                  item[field] = severityMap[item[field]] || 'major';
+                }
+              }
+            }
+          }
+          const result = JSON.stringify(obj, null, 2);
+          console.log(`[DEBUG] Fast-path fix for ${rule.id}: corrected ${field} values (no LLM call)`);
+          if (this.tracker) this.tracker.endRuleFix(result.length);
+          return result;
+        } catch { /* fall through */ }
+      }
+
+      // Fast-path fix: convert non-array fields to arrays
+      if (rule.fastPath?.enabled && rule.fastPath.type === 'json-arrays') {
+        try {
+          const { unwrapped } = this.unwrapJsonCodeFence(content);
+          const obj = JSON.parse(unwrapped);
+          const arrayFields = rule.fastPath.arrayFields || [];
+          let fixed = false;
+          for (const field of arrayFields) {
+            if (field in obj && !Array.isArray(obj[field])) {
+              const val = obj[field];
+              if (val === null || val === undefined) {
+                obj[field] = [];
+              } else if (typeof val === 'string') {
+                obj[field] = val ? [val] : [];
+              } else if (typeof val === 'object') {
+                obj[field] = [val];
+              } else {
+                obj[field] = [];
+              }
+              fixed = true;
+            }
+          }
+          if (fixed) {
+            const result = JSON.stringify(obj, null, 2);
+            console.log(`[DEBUG] Fast-path fix for ${rule.id}: converted non-array fields to arrays (no LLM call)`);
+            if (this.tracker) {
+              this.tracker.endRuleFix(result.length);
+            }
+            return result;
+          }
+        } catch { /* fall through to LLM */ }
+      }
+
+      // Fast-path fix: add missing required fields with defaults from fix prompt
+      if (rule.fastPath?.enabled && rule.fastPath.type === 'json-fields') {
+        try {
+          const { unwrapped } = this.unwrapJsonCodeFence(content);
+          const obj = JSON.parse(unwrapped);
+          const missing = (rule.fastPath.requiredFields || []).filter(f => !(f in obj));
+          if (missing.length > 0) {
+            // Parse defaults from fix prompt — use sensible fallbacks
+            const defaults = {
+              validationStatus: 'needs-improvement',
+              overallScore: 50,
+              structuralIssues: [],
+              contentIssues: [],
+              applicationFlowGaps: [],
+              strengths: ['Document structure present'],
+              improvementPriorities: [],
+              readyForPublication: false,
+            };
+            for (const field of missing) {
+              obj[field] = defaults[field] !== undefined ? defaults[field] : null;
+            }
+            const fixed = JSON.stringify(obj, null, 2);
+            console.log(`[DEBUG] Fast-path fix for ${rule.id}: added missing fields [${missing.join(', ')}] (no LLM call)`);
+            if (this.tracker) {
+              this.tracker.endRuleFix(fixed.length);
+            }
+            return fixed;
+          }
+        } catch { /* JSON parse failed — fall through to LLM */ }
+      }
+
       // Fallback to LLM fix
       const prompt = rule.fix.prompt.replace('{content}', content);
       const maxTokens = rule.fix.maxTokens || 4096;

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

@@ -21,18 +21,9 @@ export const MESSAGES = {
    * Ceremony headers with titles and documentation URLs
    */
   CEREMONY_HEADERS: {
-    'sponsor-call': {
-      title: 'Sponsor Call Ceremony',
-      url: 'https://agilevibecoding.org/ceremonies/sponsor-call'
-    },
-    'sprint-planning': {
-      title: 'Sprint Planning Ceremony',
-      url: 'https://agilevibecoding.org/ceremonies/sprint-planning'
-    },
-    'seed': {
-      title: 'Seed Ceremony',
-      url: 'https://agilevibecoding.org/ceremonies/seed'
-    }
+    'sponsor-call':   { title: 'Sponsor Call Ceremony' },
+    'sprint-planning': { title: 'Sprint Planning Ceremony' },
+    'seed':           { title: 'Seed Ceremony' },
   }
 };
 

package/cli/messaging-api.js

@@ -67,22 +67,16 @@ export function cancelCommand() {
  * Send a ceremony header (title + documentation URL)
  * Automatically prevents duplicate headers within same command execution
  *
- * @param {string} title - Ceremony title (without emoji)
- * @param {string} url - Documentation URL
- *
- * @example
- * sendCeremonyHeader('Sponsor Call Ceremony', 'https://agilevibecoding.org/ceremonies/sponsor-call');
+ * @param {string} title - Ceremony title
  */
-export function sendCeremonyHeader(title, url) {
-  const key = `${title}|${url}`;
-
-  // Prevent duplicate ceremony headers
-  if (ceremonySent.has(key)) {
+export function sendCeremonyHeader(title) {
+  // Prevent duplicate ceremony headers within the same command execution
+  if (ceremonySent.has(title)) {
     return;
   }
 
-  ceremonySent.add(key);
-  const content = `${boldCyan(title)}\n${gray('Documentation:')} ${cyan(url)}`;
+  ceremonySent.add(title);
+  const content = boldCyan(title);
   messageManager.send(MessageType.CEREMONY_HEADER, content);
 }