@su-record/vibe 2.6.34 → 2.6.41

package/hooks/scripts/skill-requirements.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+/**
+ * Skill Requirements Checker
+ * Binary existence check + platform check + install hints
+ */
+
+import { spawnSync } from 'child_process';
+
+// Binary existence cache (TTL: 5분)
+const BINARY_CACHE = new Map();
+const CACHE_TTL = 5 * 60 * 1000;
+
+// Allowed binary name pattern (security)
+const BINARY_NAME_PATTERN = /^[a-zA-Z0-9._-]+$/;
+
+/**
+ * Check if a binary exists
+ */
+export function checkBinaryExists(name) {
+  if (!BINARY_NAME_PATTERN.test(name)) {
+    return false;
+  }
+
+  // Check cache
+  const cached = BINARY_CACHE.get(name);
+  if (cached && Date.now() - cached.checkedAt < CACHE_TTL) {
+    return cached.exists;
+  }
+
+  const cmd = process.platform === 'win32' ? 'where' : 'which';
+  try {
+    const result = spawnSync(cmd, [name], {
+      shell: false,
+      timeout: 1000,
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    const exists = result.status === 0;
+    BINARY_CACHE.set(name, { exists, checkedAt: Date.now() });
+    return exists;
+  } catch {
+    BINARY_CACHE.set(name, { exists: false, checkedAt: Date.now() });
+    return false;
+  }
+}
+
+/**
+ * Check all required binaries
+ */
+export function checkAllRequirements(requires) {
+  if (!requires || !Array.isArray(requires)) return [];
+
+  return requires.map(name => ({
+    name,
+    exists: checkBinaryExists(name),
+  }));
+}
+
+/**
+ * Get install hint for current platform
+ */
+export function getInstallHint(install, platform) {
+  if (!install || typeof install !== 'object') return null;
+  platform = platform || process.platform;
+
+  if (platform === 'darwin' && install.brew) return `brew install ${install.brew}`;
+  if (platform === 'linux' && install.apt) return `apt install ${install.apt}`;
+  if (platform === 'win32' && install.choco) return `choco install ${install.choco}`;
+  if (install.npm) return `npm install -g ${install.npm}`;
+  if (install.url) return `Download: ${install.url}`;
+
+  // Try brew as fallback for darwin/linux
+  if (install.brew && platform !== 'win32') return `brew install ${install.brew}`;
+
+  return null;
+}
+
+/**
+ * Check platform compatibility
+ */
+export function checkPlatform(os) {
+  if (!os || !Array.isArray(os) || os.length === 0) return true;
+  return os.includes(process.platform);
+}

package/hooks/scripts/stop-notify.js

@@ -0,0 +1,207 @@
+/**
+ * Stop Notification Hook - Claude Code 작업 종료 시 알림 발송
+ *
+ * 지원 채널:
+ * - Discord (webhook)
+ * - Telegram (bot token + chat_id)
+ * - Slack (webhook)
+ *
+ * 환경변수:
+ * - DISCORD_WEBHOOK_URL: Discord webhook URL
+ * - TELEGRAM_BOT_TOKEN: Telegram bot token
+ * - TELEGRAM_CHAT_ID: Telegram chat ID
+ * - SLACK_WEBHOOK_URL: Slack webhook URL
+ *
+ * 설정 파일: .claude/vibe/config.json
+ * {
+ *   "notifications": {
+ *     "onStop": true,
+ *     "channels": ["discord", "telegram", "slack"]
+ *   }
+ * }
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { PROJECT_DIR, CORE_PATH } from './utils.js';
+
+// Read hook input from stdin
+let input = '';
+for await (const chunk of process.stdin) {
+  input += chunk;
+}
+
+async function sendDiscord(message, summary) {
+  const webhookUrl = process.env.DISCORD_WEBHOOK_URL;
+  if (!webhookUrl) return { sent: false, reason: 'no webhook url' };
+
+  try {
+    const payload = {
+      embeds: [{
+        title: '🔔 Claude Code Task Completed',
+        description: summary || 'Task finished',
+        color: 5763719, // Green
+        fields: [
+          { name: 'Project', value: path.basename(PROJECT_DIR) || 'Unknown', inline: true },
+          { name: 'Time', value: new Date().toLocaleString('ko-KR', { timeZone: 'Asia/Seoul' }), inline: true }
+        ],
+        footer: { text: 'VIBE Core' },
+        timestamp: new Date().toISOString()
+      }]
+    };
+
+    const response = await fetch(webhookUrl, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(payload)
+    });
+
+    return { sent: response.ok, reason: response.ok ? 'success' : `HTTP ${response.status}` };
+  } catch (err) {
+    return { sent: false, reason: err.message };
+  }
+}
+
+async function sendTelegram(message, summary) {
+  const botToken = process.env.TELEGRAM_BOT_TOKEN;
+  const chatId = process.env.TELEGRAM_CHAT_ID;
+
+  if (!botToken || !chatId) return { sent: false, reason: 'no token or chat_id' };
+
+  try {
+    const text = `🔔 *Claude Code Task Completed*\n\n` +
+      `📁 Project: \`${path.basename(PROJECT_DIR) || 'Unknown'}\`\n` +
+      `⏰ Time: ${new Date().toLocaleString('ko-KR', { timeZone: 'Asia/Seoul' })}\n\n` +
+      (summary ? `📝 ${summary}` : '');
+
+    const response = await fetch(`https://api.telegram.org/bot${botToken}/sendMessage`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        chat_id: chatId,
+        text,
+        parse_mode: 'Markdown'
+      })
+    });
+
+    const result = await response.json();
+    return { sent: result.ok, reason: result.ok ? 'success' : result.description };
+  } catch (err) {
+    return { sent: false, reason: err.message };
+  }
+}
+
+async function sendSlack(message, summary) {
+  const webhookUrl = process.env.SLACK_WEBHOOK_URL;
+  if (!webhookUrl) return { sent: false, reason: 'no webhook url' };
+
+  try {
+    const payload = {
+      blocks: [
+        {
+          type: 'header',
+          text: { type: 'plain_text', text: '🔔 Claude Code Task Completed', emoji: true }
+        },
+        {
+          type: 'section',
+          fields: [
+            { type: 'mrkdwn', text: `*Project:*\n${path.basename(PROJECT_DIR) || 'Unknown'}` },
+            { type: 'mrkdwn', text: `*Time:*\n${new Date().toLocaleString('ko-KR', { timeZone: 'Asia/Seoul' })}` }
+          ]
+        }
+      ]
+    };
+
+    if (summary) {
+      payload.blocks.push({
+        type: 'section',
+        text: { type: 'mrkdwn', text: `*Summary:*\n${summary}` }
+      });
+    }
+
+    const response = await fetch(webhookUrl, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(payload)
+    });
+
+    return { sent: response.ok, reason: response.ok ? 'success' : `HTTP ${response.status}` };
+  } catch (err) {
+    return { sent: false, reason: err.message };
+  }
+}
+
+async function main() {
+  // Parse input
+  let stopReason = '';
+  let summary = '';
+  try {
+    const data = JSON.parse(input);
+    stopReason = data.stop_reason || data.stopReason || '';
+    summary = data.summary || data.message || '';
+  } catch {
+    // Not JSON, use as-is
+    summary = input.trim();
+  }
+
+  // Load config
+  let config = { notifications: { onStop: true, channels: ['discord', 'telegram', 'slack'] } };
+  const configPath = path.join(PROJECT_DIR, '.claude/vibe/config.json');
+
+  try {
+    if (fs.existsSync(configPath)) {
+      const rawConfig = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      if (rawConfig.notifications) {
+        config.notifications = { ...config.notifications, ...rawConfig.notifications };
+      }
+    }
+  } catch { /* use defaults */ }
+
+  // Check if notifications enabled
+  if (!config.notifications.onStop) {
+    console.log('[Stop Notify] Notifications disabled');
+    return;
+  }
+
+  const channels = config.notifications.channels || ['discord', 'telegram', 'slack'];
+  const results = [];
+
+  // Send notifications in parallel
+  const promises = [];
+
+  if (channels.includes('discord')) {
+    promises.push(sendDiscord(stopReason, summary).then(r => results.push({ channel: 'discord', ...r })));
+  }
+
+  if (channels.includes('telegram')) {
+    promises.push(sendTelegram(stopReason, summary).then(r => results.push({ channel: 'telegram', ...r })));
+  }
+
+  if (channels.includes('slack')) {
+    promises.push(sendSlack(stopReason, summary).then(r => results.push({ channel: 'slack', ...r })));
+  }
+
+  await Promise.all(promises);
+
+  // Log results
+  const sent = results.filter(r => r.sent);
+  const failed = results.filter(r => !r.sent);
+
+  if (sent.length > 0) {
+    console.log(`[Stop Notify] Sent to: ${sent.map(r => r.channel).join(', ')}`);
+  }
+
+  if (failed.length > 0 && failed.some(r => channels.includes(r.channel))) {
+    // Only log failures for explicitly configured channels with valid credentials
+    const relevantFailures = failed.filter(r =>
+      r.reason !== 'no webhook url' && r.reason !== 'no token or chat_id'
+    );
+    if (relevantFailures.length > 0) {
+      console.log(`[Stop Notify] Failed: ${relevantFailures.map(r => `${r.channel} (${r.reason})`).join(', ')}`);
+    }
+  }
+}
+
+main().catch(err => {
+  console.error('[Stop Notify] Error:', err.message);
+});

package/hooks/scripts/utils.js

@@ -11,12 +11,12 @@ import os from 'os';
 // 플랫폼 감지
 const IS_WINDOWS = os.platform() === 'win32';
 
-// 스크립트 위치에서 VIBE_PATH 자동 감지
-// hooks/scripts/utils.js → hooks → VIBE_PATH
+// 스크립트 위치에서 CORE_PATH 자동 감지
+// hooks/scripts/utils.js → hooks → CORE_PATH
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const DETECTED_VIBE_PATH = path.resolve(__dirname, '..', '..');
+const DETECTED_CORE_PATH = path.resolve(__dirname, '..', '..');
 
-export const VIBE_PATH = process.env.VIBE_PATH || DETECTED_VIBE_PATH;
+export const CORE_PATH = process.env.CORE_PATH || DETECTED_CORE_PATH;
 export const PROJECT_DIR = process.env.CLAUDE_PROJECT_DIR || '.';
 
 /**
@@ -65,8 +65,8 @@ function getGlobalNpmPath() {
  * 우선순위: 로컬 빌드 → 전역 npm
  */
 export function getToolsBaseUrl() {
-  const localDist = path.join(VIBE_PATH, 'dist', 'tools');
-  const globalPackage = path.join(getGlobalNpmPath(), '@su-record', 'vibe', 'dist', 'tools');
+  const localDist = path.join(CORE_PATH, 'dist', 'tools');
+  const globalPackage = path.join(getGlobalNpmPath(), '@su-record', 'core', 'dist', 'tools');
 
   // 1. 로컬 빌드된 파일 확인 (개발 환경)
   const localIndex = path.join(localDist, 'index.js');
@@ -83,8 +83,8 @@ export function getToolsBaseUrl() {
  * 우선순위: 로컬 빌드 → 전역 npm
  */
 export function getLibBaseUrl() {
-  const localDist = path.join(VIBE_PATH, 'dist', 'lib');
-  const globalPackage = path.join(getGlobalNpmPath(), '@su-record', 'vibe', 'dist', 'lib');
+  const localDist = path.join(CORE_PATH, 'dist', 'infra', 'lib');
+  const globalPackage = path.join(getGlobalNpmPath(), '@su-record', 'core', 'dist', 'infra', 'lib');
 
   // 1. 로컬 빌드된 파일 확인 (개발 환경)
   const localGptApi = path.join(localDist, 'gpt-api.js');

package/package.json

@@ -1,11 +1,15 @@
 {
   "name": "@su-record/vibe",
-  "version": "2.6.34",
-  "description": "Vibe - Claude Code exclusive SPEC-driven AI coding framework with 35+ integrated tools",
+  "version": "2.6.41",
+  "description": "Personalized AI agent for Claude Code — 46 agents, 41+ tools, multi-LLM orchestration",
   "type": "module",
   "main": "dist/cli/index.js",
   "exports": {
     ".": "./dist/cli/index.js",
+    "./agent": {
+      "types": "./dist/agent/index.d.ts",
+      "default": "./dist/agent/index.js"
+    },
     "./tools": "./dist/tools/index.js",
     "./tools/memory": "./dist/tools/memory/index.js",
     "./tools/convention": "./dist/tools/convention/index.js",
@@ -13,29 +17,47 @@
     "./tools/ui": "./dist/tools/ui/index.js",
     "./tools/time": "./dist/tools/time/index.js",
     "./tools/interaction": "./dist/tools/interaction/index.js",
-    "./orchestrator": "./dist/orchestrator/index.js",
-    "./lib/gpt": "./dist/lib/gpt-api.js",
-    "./lib/gemini": "./dist/lib/gemini-api.js"
+    "./orchestrator": "./dist/infra/orchestrator/index.js",
+    "./interface": {
+      "types": "./dist/interface/index.d.ts",
+      "default": "./dist/interface/index.js"
+    },
+    "./router": {
+      "types": "./dist/router/index.d.ts",
+      "default": "./dist/router/index.js"
+    },
+    "./memory": {
+      "types": "./dist/infra/lib/memory/index.d.ts",
+      "default": "./dist/infra/lib/memory/index.js"
+    },
+    "./policy": {
+      "types": "./dist/infra/policy/index.d.ts",
+      "default": "./dist/infra/policy/index.js"
+    },
+    "./lib/gpt": "./dist/infra/lib/gpt-api.js",
+    "./lib/gemini": "./dist/infra/lib/gemini-api.js",
+    "./lib/kimi": "./dist/infra/lib/az-api.js",
+    "./lib/az": "./dist/infra/lib/az-api.js"
   },
   "bin": {
-    "vibe": "./dist/cli/index.js"
+    "vibe": "dist/cli/index.js"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && test -f .env || cp .env.example .env && chmod +x dist/cli/index.js",
     "dev": "tsc --watch",
     "test": "vitest run",
     "test:watch": "vitest",
-    "prepublishOnly": "npm run build",
-    "postinstall": "node dist/cli/postinstall.js"
+    "prepublishOnly": "pnpm build",
+    "postinstall": "node -e \"import('./dist/cli/postinstall/main.js').then(m=>m.main()).catch(()=>{})\"",
+    "release": "pnpm version patch --no-git-tag-version && pnpm build && pnpm publish --no-git-checks"
   },
   "keywords": [
     "ai",
-    "vibe",
+    "core",
     "coding",
     "spec-driven",
     "claude",
-    "mcp",
-    "framework",
+    "agent",
     "requirements",
     "user-story",
     "ultrawork",
@@ -49,23 +71,36 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/su-record/vibe.git"
+    "url": "git+https://github.com/su-record/core.git"
+  },
+  "homepage": "https://github.com/su-record/core#readme",
+  "publishConfig": {
+    "access": "public"
   },
-  "homepage": "https://github.com/su-record/vibe#readme",
   "engines": {
     "node": ">=18.0.0"
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.6",
-    "better-sqlite3": "^12.4.1",
+    "@ast-grep/napi": "^0.40.5",
+    "@clack/prompts": "^1.0.0",
+    "better-sqlite3": "^12.6.2",
     "chalk": "^5.3.0",
-    "glob": "^11.0.3",
-    "ts-morph": "^26.0.0"
+    "glob": "^13.0.1",
+    "node-cron": "^3.0.3",
+    "papaparse": "^5.5.3",
+    "playwright": "^1.58.2",
+    "ts-morph": "^26.0.0",
+    "uuidv7": "^1.1.0",
+    "vscode-languageserver-protocol": "^3.17.5",
+    "zod": "^4.3.6"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",
-    "@types/glob": "^8.1.0",
     "@types/node": "^22.0.0",
+    "@types/node-cron": "^3.0.11",
+    "@types/papaparse": "^5.5.2",
+    "ajv": "^8.17.1",
     "typescript": "^5.5.4",
     "vitest": "^4.0.9"
   },
@@ -77,6 +112,8 @@
     "agents/",
     "skills/",
     "hooks/",
+    ".env.example",
+    ".env",
     "CLAUDE.md",
     "README.md",
     "LICENSE"

package/skills/brand-assets/SKILL.md

@@ -0,0 +1,138 @@
+---
+name: brand-assets
+description: "Auto-generate app icons and favicons from SPEC brand information using Gemini Image API"
+triggers: [icon, favicon, brand, logo, app icon, branding, assets]
+priority: 65
+---
+# Brand Assets Generation Skill
+
+Auto-generate app icons and favicons based on SPEC brand information.
+
+## When to Use
+
+- First-time project setup with `/vibe.run`
+- When SPEC contains brand/design information
+- When Gemini API key is configured
+
+## Prerequisites
+
+- Gemini API key configured (`vibe gemini auth`)
+- SPEC with brand context (app name, colors, style)
+
+## Generated Assets
+
+### Web
+- `favicon.ico` (16x16, 32x32, 48x48)
+- `favicon-16x16.png`
+- `favicon-32x32.png`
+- `apple-touch-icon.png` (180x180)
+- `android-chrome-192x192.png`
+- `android-chrome-512x512.png`
+
+### Mobile (if applicable)
+- iOS: `AppIcon.appiconset/` with all sizes
+- Android: `mipmap-*/` adaptive icons
+
+## SPEC Brand Section
+
+For best results, include brand info in your SPEC:
+
+```yaml
+<context>
+Brand:
+  - App Name: MyApp
+  - Primary Color: #2F6BFF
+  - Style: Modern, minimal, flat design
+  - Icon Concept: Abstract geometric shape representing connectivity
+</context>
+```
+
+## Generation Flow
+
+```
+SPEC Brand Info
+      |
+      v
+Extract: name, colors, style keywords
+      |
+      v
+Generate Prompt: "App icon for [name], [style], [colors]..."
+      |
+      v
+Gemini Image API (gemini-2.5-flash-image)
+      |
+      v
+Resize & Convert: All platform sizes
+      |
+      v
+Save to: public/ or assets/
+```
+
+## Auto-Trigger Conditions
+
+1. First `/vibe.run` execution (no existing icons)
+2. SPEC contains brand/design context
+3. Gemini API key is available
+4. `--generate-icons` flag passed
+
+## Skip Conditions
+
+- Icons already exist (unless `--regenerate-icons`)
+- No brand info in SPEC
+- Gemini API not configured
+
+## Prompt Template
+
+```
+Create a modern app icon for "[APP_NAME]".
+
+Style: [STYLE_KEYWORDS]
+Primary color: [PRIMARY_COLOR]
+Design: Minimalist, professional, suitable for mobile app
+Format: Square, clean edges, simple recognizable shape
+Background: Solid color or subtle gradient
+
+Requirements:
+- Works at small sizes (16x16 to 512x512)
+- No text or letters
+- Single focal element
+- High contrast for visibility
+```
+
+## Manual Usage
+
+```bash
+# Resolve path first: node -e "console.log(require('path').join(process.env.APPDATA || require('os').homedir() + '/.config', 'vibe/hooks/scripts/llm-orchestrate.js'))"
+# Generate via llm-orchestrate (when Gemini configured)
+node "[LLM_SCRIPT]" gemini image "App icon for MyApp, primary color #2F6BFF, square format 1:1, simple recognizable design, works well at small sizes, no text or letters, solid or gradient background, modern minimalist" --output "./public/app-icon.png"
+```
+
+## Integration with /vibe.run
+
+During Phase 1 (Setup), if brand assets don't exist:
+
+1. Parse SPEC for brand context
+2. Generate icon via Gemini Image API
+3. Create all size variants
+4. Place in appropriate directories
+5. Update manifest files if needed
+
+## Fallback Strategy
+
+If Gemini Image fails:
+1. Generate text-based monogram icon (first letter)
+2. Use project primary color as background
+3. Create simple geometric placeholder
+
+## Output Structure
+
+```
+public/
+  favicon.ico
+  favicon-16x16.png
+  favicon-32x32.png
+  apple-touch-icon.png
+  android-chrome-192x192.png
+  android-chrome-512x512.png
+  site.webmanifest
+```