@su-record/vibe 2.6.34 → 2.6.41

package/hooks/scripts/llm-orchestrate.js

@@ -1,12 +1,12 @@
 /**
- * UserPromptSubmit Hook - LLM 오케스트레이션 (GPT/Gemini)
+ * UserPromptSubmit Hook - LLM 오케스트레이션 (GPT/Gemini/AZ)
  *
  * Usage:
  *   node llm-orchestrate.js <provider> <mode> "prompt"
  *   node llm-orchestrate.js <provider> <mode> "systemPrompt" "prompt"
  *
- *   provider: gpt | gemini
- *   mode: orchestrate | orchestrate-json | image
+ *   provider: gpt | gemini | kimi
+ *   mode: orchestrate | orchestrate-json | image | analyze-image
  *
  * Image Mode:
  *   node llm-orchestrate.js gemini image "prompt" --output "./image.png"
@@ -17,12 +17,20 @@
  *   - Auto fallback: gemini → gpt, gpt → gemini
  *   - Overload/rate-limit detection
  *   - Image generation (Gemini only, Nano Banana model)
+ *   - Image analysis (Gemini multimodal)
+ *
+ * Analyze-Image Mode:
+ *   node llm-orchestrate.js gemini analyze-image "./image.png" "Analyze this UI"
+ *   node llm-orchestrate.js gemini analyze-image "./image.png" "prompt" --system "system prompt"
  *
  * Input: JSON from stdin with { prompt: string } (when no CLI args)
  */
 import { getLibBaseUrl } from './utils.js';
 import fs from 'fs';
 import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
+import { execSync, spawn } from 'child_process';
 
 const LIB_URL = getLibBaseUrl();
 const DEFAULT_SYSTEM_PROMPT = 'You are a helpful assistant.';
@@ -73,12 +81,14 @@ function sleep(ms) {
 // ============================================
 
 function parseImageArgs(args) {
-  const result = { prompt: null, output: './generated-image.png', size: '1024x1024' };
+  const result = { prompt: null, output: './generated-image.png', size: '1024x1024', model: 'nano-banana' };
   for (let i = 0; i < args.length; i++) {
     if (args[i] === '--output' || args[i] === '-o') {
       result.output = args[++i];
     } else if (args[i] === '--size' || args[i] === '-s') {
       result.size = args[++i];
+    } else if (args[i] === '--pro') {
+      result.model = 'nano-banana-pro';
     } else if (!args[i].startsWith('-') && !result.prompt) {
       result.prompt = args[i];
     }
@@ -86,13 +96,127 @@ function parseImageArgs(args) {
   return result;
 }
 
+// ============================================
+// Image Analysis (delegates to gemini-api)
+// ============================================
+
+function parseAnalyzeImageArgs(args) {
+  const result = { imagePath: null, prompt: null, systemPrompt: null };
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--system' || args[i] === '-s') {
+      result.systemPrompt = args[++i];
+    } else if (!args[i].startsWith('-')) {
+      if (!result.imagePath) {
+        result.imagePath = args[i];
+      } else if (!result.prompt) {
+        result.prompt = args[i];
+      }
+    }
+  }
+  return result;
+}
+
+// ============================================
+// Voice Transcription (record + Gemini STT)
+// ============================================
+
+function parseVoiceArgs(args) {
+  const result = { pro: false, lang: null, duration: 60 };
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--pro') {
+      result.pro = true;
+    } else if (args[i] === '--lang' || args[i] === '-l') {
+      result.lang = args[++i];
+    } else if (args[i] === '--duration' || args[i] === '-d') {
+      result.duration = parseInt(args[++i], 10) || 60;
+    }
+  }
+  return result;
+}
+
+function checkSoxInstalled() {
+  try {
+    execSync('sox --version', { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function recordAudio(outputPath, maxDuration) {
+  return new Promise((resolve, reject) => {
+    const soxProcess = spawn('sox', [
+      '-d',
+      '-r', '16000',
+      '-c', '1',
+      '-b', '16',
+      '-t', 'wav',
+      outputPath,
+      'trim', '0', String(maxDuration),
+    ], { stdio: ['pipe', 'pipe', 'pipe'] });
+
+    let stderrData = '';
+    soxProcess.stderr.on('data', (data) => {
+      stderrData += data.toString();
+    });
+
+    // Enter 키로 녹음 중지
+    if (process.stdin.setRawMode) {
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+
+    const onKeypress = (key) => {
+      if (key[0] === 13 || key[0] === 10 || key[0] === 3) {
+        if (process.stdin.setRawMode) {
+          process.stdin.setRawMode(false);
+        }
+        process.stdin.pause();
+        process.stdin.removeListener('data', onKeypress);
+        soxProcess.kill('SIGTERM');
+      }
+    };
+    process.stdin.on('data', onKeypress);
+
+    soxProcess.on('close', () => {
+      if (process.stdin.setRawMode) {
+        process.stdin.setRawMode(false);
+      }
+      process.stdin.pause();
+      process.stdin.removeListener('data', onKeypress);
+
+      if (fs.existsSync(outputPath) && fs.statSync(outputPath).size > 44) {
+        resolve(outputPath);
+      } else {
+        reject(new Error(`Recording failed: ${stderrData || 'empty audio'}`));
+      }
+    });
+
+    soxProcess.on('error', (err) => {
+      if (process.stdin.setRawMode) {
+        process.stdin.setRawMode(false);
+      }
+      process.stdin.pause();
+      process.stdin.removeListener('data', onKeypress);
+      reject(new Error(`Sox process error: ${err.message}`));
+    });
+  });
+}
+
 async function callProvider(providerName, prompt, sysPrompt, jsonMode) {
-  const modulePath = `${LIB_URL}${providerName}-api.js`;
+  // kimi는 az-api.js의 별칭 (Azure Foundry Kimi K2.5)
+  const moduleKey = providerName === 'kimi' ? 'az' : providerName;
+  const modulePath = `${LIB_URL}${moduleKey}-api.js`;
   const module = await import(modulePath);
 
-  const orchestrateFn = providerName === 'gpt'
-    ? module.vibeGptOrchestrate
-    : module.vibeGeminiOrchestrate;
+  let orchestrateFn;
+  if (moduleKey === 'gpt') {
+    orchestrateFn = module.coreGptOrchestrate;
+  } else if (moduleKey === 'az') {
+    orchestrateFn = module.coreAzOrchestrate;
+  } else {
+    orchestrateFn = module.coreGeminiOrchestrate;
+  }
 
   return await orchestrateFn(prompt, sysPrompt, { jsonMode });
 }
@@ -148,14 +272,16 @@ async function main() {
       fs.mkdirSync(outputDir, { recursive: true });
     }
 
-    console.error(`[IMAGE] Generating with Nano Banana...`);
+    const modelLabel = imageArgs.model === 'nano-banana-pro' ? 'Nano Banana Pro' : 'Nano Banana';
+    console.error(`[IMAGE] Generating with ${modelLabel}...`);
     console.error(`  Prompt: ${imageArgs.prompt}`);
     console.error(`  Size: ${imageArgs.size}`);
+    console.error(`  Model: ${modelLabel}`);
     console.error(`  Output: ${imageArgs.output}`);
 
     try {
       const geminiApi = await import(`${LIB_URL}gemini-api.js`);
-      const image = await geminiApi.generateImage(imageArgs.prompt, { size: imageArgs.size });
+      const image = await geminiApi.generateImage(imageArgs.prompt, { size: imageArgs.size, model: imageArgs.model });
       fs.writeFileSync(imageArgs.output, image.data);
       const stats = fs.statSync(imageArgs.output);
       const sizeKB = (stats.size / 1024).toFixed(1);
@@ -177,53 +303,192 @@ async function main() {
     return;
   }
 
+  // Analyze-image mode handling
+  if (mode === 'analyze-image') {
+    if (provider !== 'gemini') {
+      console.log('[ANALYZE-IMAGE] Error: Image analysis only supports gemini provider');
+      return;
+    }
+
+    const analyzeArgs = parseAnalyzeImageArgs(process.argv.slice(4));
+    if (!analyzeArgs.imagePath) {
+      console.log('[ANALYZE-IMAGE] Error: image path is required');
+      return;
+    }
+    if (!analyzeArgs.prompt) {
+      console.log('[ANALYZE-IMAGE] Error: analysis prompt is required');
+      return;
+    }
+
+    const absolutePath = path.resolve(analyzeArgs.imagePath);
+    if (!fs.existsSync(absolutePath)) {
+      console.log(JSON.stringify({
+        success: false,
+        error: `Image file not found: ${absolutePath}`,
+        imagePath: analyzeArgs.imagePath,
+      }));
+      return;
+    }
+
+    console.error(`[ANALYZE-IMAGE] Analyzing image with Gemini...`);
+    console.error(`  Image: ${absolutePath}`);
+    console.error(`  Prompt: ${analyzeArgs.prompt}`);
+
+    try {
+      const geminiApi = await import(`${LIB_URL}gemini-api.js`);
+      const options = {};
+      if (analyzeArgs.systemPrompt) {
+        options.systemPrompt = analyzeArgs.systemPrompt;
+      }
+      const analysis = await geminiApi.analyzeImage(absolutePath, analyzeArgs.prompt, options);
+
+      console.log(JSON.stringify({
+        success: true,
+        analysis,
+        imagePath: absolutePath,
+      }));
+    } catch (err) {
+      console.log(JSON.stringify({
+        success: false,
+        error: err.message,
+        imagePath: absolutePath,
+      }));
+    }
+    return;
+  }
+
+  // Voice mode handling
+  if (mode === 'voice') {
+    if (provider !== 'gemini') {
+      console.log(JSON.stringify({
+        success: false,
+        error: 'Voice transcription only supports gemini provider',
+      }));
+      return;
+    }
+
+    if (!checkSoxInstalled()) {
+      console.log(JSON.stringify({
+        success: false,
+        error: 'sox is not installed. Install with: brew install sox (macOS) or apt install sox (Linux)',
+      }));
+      return;
+    }
+
+    const voiceArgs = parseVoiceArgs(process.argv.slice(4));
+    const voiceModel = voiceArgs.pro ? 'gemini-3-pro' : 'gemini-3-flash';
+    const tmpFile = path.join(os.tmpdir(), `vibe-voice-${crypto.randomUUID()}.wav`);
+
+    console.error(`[VOICE] Recording audio... (press Enter to stop, max ${voiceArgs.duration}s)`);
+    console.error(`  Model: ${voiceModel}`);
+    if (voiceArgs.lang) {
+      console.error(`  Language: ${voiceArgs.lang}`);
+    }
+
+    try {
+      await recordAudio(tmpFile, voiceArgs.duration);
+
+      const stats = fs.statSync(tmpFile);
+      const fileSizeKB = (stats.size / 1024).toFixed(1);
+      console.error(`[VOICE] Recording complete (${fileSizeKB} KB). Transcribing...`);
+
+      const geminiApi = await import(`${LIB_URL}gemini-api.js`);
+      const result = await geminiApi.transcribeAudio(tmpFile, {
+        model: voiceModel,
+        language: voiceArgs.lang || undefined,
+      });
+
+      try { fs.unlinkSync(tmpFile); } catch { /* ignore */ }
+
+      console.log(JSON.stringify({
+        success: true,
+        transcription: result.transcription,
+        duration: result.duration,
+        model: result.model,
+      }));
+    } catch (err) {
+      try { fs.unlinkSync(tmpFile); } catch { /* ignore */ }
+
+      console.log(JSON.stringify({
+        success: false,
+        error: err.message,
+      }));
+    }
+    return;
+  }
+
   // Text generation mode (orchestrate / orchestrate-json)
   let prompt;
   let systemPrompt = DEFAULT_SYSTEM_PROMPT;
 
-  // CLI argument가 있으면 사용
-  // Usage 1: node script.js gpt orchestrate "system prompt" "user prompt"
-  // Usage 2: node script.js gpt orchestrate "user prompt" (uses default system prompt)
-  const arg4 = process.argv[4]?.trim();
-  const arg5 = process.argv.slice(5).join(' ').trim();
-
-  if (arg5) {
-    // 5번째 인자가 있으면: arg4=시스템 프롬프트, arg5=사용자 프롬프트
-    systemPrompt = arg4;
-    prompt = arg5;
-  } else if (arg4) {
-    // 4번째 인자만 있으면: arg4=사용자 프롬프트 (시스템 프롬프트는 기본값)
-    prompt = arg4;
-  } else {
-    // Hook에서 호출: stdin으로 JSON 입력
-    let inputData = '';
-    for await (const chunk of process.stdin) {
-      inputData += chunk;
-    }
-
+  // --input <file> 플래그를 먼저 확인 (위치 인자보다 우선)
+  const inputFlagIdx = process.argv.indexOf('--input');
+  if (inputFlagIdx !== -1 && process.argv[inputFlagIdx + 1]) {
+    const inputFile = process.argv[inputFlagIdx + 1];
     try {
+      const inputData = fs.readFileSync(inputFile, 'utf8');
       const parsed = JSON.parse(inputData);
       prompt = parsed.prompt;
-    } catch {
-      console.log(`[${provider.toUpperCase()}] Error: Invalid JSON input`);
+      if (parsed.systemPrompt) {
+        systemPrompt = parsed.systemPrompt;
+      }
+    } catch (err) {
+      console.log(`[${provider.toUpperCase()}] Error: Failed to read input file: ${err.message}`);
       return;
     }
+  } else {
+    // CLI argument 사용
+    // Usage 1: node script.js gpt orchestrate "system prompt" "user prompt"
+    // Usage 2: node script.js gpt orchestrate "user prompt" (uses default system prompt)
+    const arg4 = process.argv[4]?.trim();
+    const arg5 = process.argv.slice(5).join(' ').trim();
+
+    if (arg5) {
+      // 5번째 인자가 있으면: arg4=시스템 프롬프트, arg5=사용자 프롬프트
+      systemPrompt = arg4;
+      prompt = arg5;
+    } else if (arg4) {
+      // 4번째 인자만 있으면: arg4=사용자 프롬프트 (시스템 프롬프트는 기본값)
+      prompt = arg4;
+    } else {
+      // Hook에서 호출: stdin으로 JSON 입력 (fallback)
+      let inputData = '';
+      for await (const chunk of process.stdin) {
+        inputData += chunk;
+      }
+
+      try {
+        const parsed = JSON.parse(inputData);
+        prompt = parsed.prompt;
+      } catch {
+        console.log(`[${provider.toUpperCase()}] Error: Invalid JSON input`);
+        return;
+      }
+    }
   }
 
   // 접두사 제거
   const prefixPatterns = {
     gpt: /^(gpt[-.\s]|지피티-|vibe-gpt-)\s*/i,
     gemini: /^(gemini[-.\s]|제미나이-|vibe-gemini-)\s*/i,
+    kimi: /^(kimi[-.\s]|키미-|vibe-kimi-)\s*/i,
   };
   const cleanPrompt = prompt.replace(prefixPatterns[provider] || /^/, '').trim();
   const jsonMode = mode === 'orchestrate-json';
 
-  // Provider chain: primary → fallback
-  const fallbackProvider = provider === 'gpt' ? 'gemini' : 'gpt';
-  const providerChain = [provider, fallbackProvider];
+  // Provider chain: primary → kimi fallback → cross fallback
+  const providerLabels = { gpt: 'GPT-5.2', gemini: 'Gemini-3', kimi: 'Kimi' };
+  let providerChain;
+  if (provider === 'kimi') {
+    providerChain = ['kimi', 'gpt', 'gemini'];
+  } else if (provider === 'gpt') {
+    providerChain = ['gpt', 'kimi', 'gemini'];
+  } else {
+    providerChain = ['gemini', 'kimi', 'gpt'];
+  }
 
   for (const currentProvider of providerChain) {
-    const label = currentProvider === 'gpt' ? 'GPT-5.2' : 'Gemini-3';
+    const label = providerLabels[currentProvider] || currentProvider.toUpperCase();
     const result = await callWithRetry(currentProvider, cleanPrompt, systemPrompt, jsonMode);
 
     if (result.success) {
@@ -233,8 +498,9 @@ async function main() {
 
     // Log failure and try fallback
     if (currentProvider !== providerChain[providerChain.length - 1]) {
-      const fallbackLabel = fallbackProvider === 'gpt' ? 'GPT' : 'Gemini';
-      console.error(`[${currentProvider.toUpperCase()}] Failed: ${result.error}. Falling back to ${fallbackLabel}...`);
+      const nextProvider = providerChain[providerChain.indexOf(currentProvider) + 1];
+      const nextLabel = providerLabels[nextProvider] || nextProvider.toUpperCase();
+      console.error(`[${currentProvider.toUpperCase()}] Failed: ${result.error}. Falling back to ${nextLabel}...`);
     } else {
       // All providers failed
       console.log(`[LLM] Error: All providers failed. Last error: ${result.error}`);

package/hooks/scripts/post-edit.js

@@ -1,13 +1,9 @@
 /**
- * PostToolUse Hook - Edit 후 자동 포맷팅 및 TypeScript 체크
+ * PostToolUse Hook - Edit 후 console.log 감지
  *
- * 기능:
- * - TypeScript/JavaScript 파일 수정 시 자동 Prettier 포맷팅
- * - TypeScript 파일 수정 시 타입 체크
- * - console.log 감지 및 경고
+ * NOTE: tsc, prettier 제거 — 빌드/커밋 시점에 실행하므로 Edit마다 불필요
  */
 import { execSync } from 'child_process';
-import { existsSync } from 'fs';
 import { PROJECT_DIR } from './utils.js';
 
 // Claude Code에서 전달받는 환경변수에서 파일 경로 추출
@@ -32,45 +28,6 @@ function main() {
 
     const results = [];
 
-    // Prettier 포맷팅 (prettier가 설치된 경우만)
-    const prettierConfig = [
-      `${PROJECT_DIR}/.prettierrc`,
-      `${PROJECT_DIR}/.prettierrc.json`,
-      `${PROJECT_DIR}/.prettierrc.js`,
-      `${PROJECT_DIR}/prettier.config.js`,
-    ].find(p => existsSync(p));
-
-    if (prettierConfig || existsSync(`${PROJECT_DIR}/node_modules/.bin/prettier`)) {
-      try {
-        execSync(`npx prettier --write "${filePath}" 2>/dev/null`, {
-          cwd: PROJECT_DIR,
-          stdio: 'pipe',
-          timeout: 10000,
-        });
-        results.push('formatted');
-      } catch {
-        // Prettier 실패는 무시
-      }
-    }
-
-    // TypeScript 타입 체크 (tsconfig가 있는 경우만)
-    if (isTs && existsSync(`${PROJECT_DIR}/tsconfig.json`)) {
-      try {
-        execSync(`npx tsc --noEmit --skipLibCheck 2>&1 | head -5`, {
-          cwd: PROJECT_DIR,
-          stdio: 'pipe',
-          timeout: 30000,
-        });
-        results.push('types OK');
-      } catch (e) {
-        const output = e.stdout?.toString() || '';
-        const errorCount = (output.match(/error TS/g) || []).length;
-        if (errorCount > 0) {
-          results.push(`${errorCount} type errors`);
-        }
-      }
-    }
-
     // console.log 감지
     try {
       const grepResult = execSync(

package/hooks/scripts/post-tool-verify.js

@@ -4,7 +4,7 @@
  * 도구 실행 후 결과 검증 및 에러 복구 힌트 제공
  */
 
-import { VIBE_PATH, PROJECT_DIR } from './utils.js';
+import { CORE_PATH, PROJECT_DIR } from './utils.js';
 
 // 에러 패턴 및 복구 힌트
 const ERROR_RECOVERY_HINTS = {

package/hooks/scripts/pre-tool-guard.js

@@ -4,7 +4,7 @@
  * 위험한 도구 사용 전 검증 및 경고
  */
 
-import { VIBE_PATH, PROJECT_DIR } from './utils.js';
+import { CORE_PATH, PROJECT_DIR } from './utils.js';
 
 // 위험한 명령어 패턴
 const DANGEROUS_PATTERNS = {

package/hooks/scripts/prompt-dispatcher.js

@@ -82,7 +82,7 @@ const DISPATCH_RULES = [
     label: 'e2e-echo',
   },
 
-  // 외부 LLM 호출 (GPT/Gemini) - 패턴 매칭 필수
+  // 외부 LLM 호출 (GPT/Gemini/Kimi) - 패턴 매칭 필수
   {
     pattern: /아키텍처.*(검토|리뷰|분석)|architecture.*(review|analyz)|설계.*검토|구조.*분석.*해/i,
     script: 'llm-orchestrate.js',
@@ -107,6 +107,18 @@ const DISPATCH_RULES = [
     args: ['gemini', 'orchestrate', 'You are a code analysis expert. Review and analyze the code.'],
     label: 'gemini-analysis',
   },
+  {
+    pattern: /코드.*리뷰|code.*review|PR.*리뷰|리뷰.*해줘.*코드/i,
+    script: 'llm-orchestrate.js',
+    args: ['kimi', 'orchestrate', 'You are a code review expert. Review the code for best practices, security, and performance.'],
+    label: 'kimi-codereview',
+  },
+  {
+    pattern: /추론.*해|reasoning|복잡.*분석|deep.*analysis/i,
+    script: 'llm-orchestrate.js',
+    args: ['kimi', 'orchestrate', 'You are a reasoning expert. Analyze the problem deeply and provide detailed reasoning.'],
+    label: 'kimi-reasoning',
+  },
 
   // 테스트용
   {
@@ -121,6 +133,12 @@ const DISPATCH_RULES = [
     args: ['gemini', 'orchestrate', 'You are a helpful assistant. Answer the user\'s question clearly and concisely.'],
     label: 'test-gemini',
   },
+  {
+    pattern: /^test-kimi/i,
+    script: 'llm-orchestrate.js',
+    args: ['kimi', 'orchestrate', 'You are a helpful assistant. Answer the user\'s question clearly and concisely.'],
+    label: 'test-kimi',
+  },
 ];
 
 // 매칭된 스크립트 실행
@@ -159,3 +177,40 @@ for (const rule of DISPATCH_RULES) {
 }
 
 await Promise.all(execPromises);
+
+// Evolution: Gap detection — log unmatched prompts for skill gap analysis
+const matched = DISPATCH_RULES.some(r =>
+  r.label !== 'skip' && r.label !== 'keyword' &&
+  r.pattern !== null && r.pattern.test(prompt) &&
+  (r.script || r.echo)
+);
+
+if (!matched) {
+  setImmediate(async () => {
+    try {
+      const configPath = path.join(process.env.CLAUDE_PROJECT_DIR || '.', '.claude', 'vibe', 'config.json');
+      let gapEnabled = true;
+      try {
+        const fs = await import('fs');
+        if (fs.existsSync(configPath)) {
+          const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+          gapEnabled = config.evolution?.gapDetection !== false && config.evolution?.enabled !== false;
+        }
+      } catch { /* ignore */ }
+
+      if (gapEnabled) {
+        const LIB_BASE = (await import('./utils.js')).getLibBaseUrl();
+        const [memMod, gapMod] = await Promise.all([
+          import(`${LIB_BASE}memory/MemoryStorage.js`),
+          import(`${LIB_BASE}evolution/SkillGapDetector.js`),
+        ]);
+        const storage = new memMod.MemoryStorage(process.env.CLAUDE_PROJECT_DIR || '.');
+        const detector = new gapMod.SkillGapDetector(storage);
+        detector.logMiss(prompt.slice(0, 200));
+        storage.close();
+      }
+    } catch (e) {
+      process.stderr.write(`[Evolution] Gap log error: ${e.message}\n`);
+    }
+  });
+}