vibe-collab 0.1.0

package/README.md

@@ -0,0 +1,177 @@
+# Vibe Orchestrator
+
+**누가 어떤 AI를 써도, 항상 한 팀처럼 작동하는 바이브 코딩 협업 도구**
+
+[![npm version](https://img.shields.io/npm/v/vibe-orchestrator)](https://www.npmjs.com/package/vibe-orchestrator)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.7-blue)](https://www.typescriptlang.org/)
+[![MCP](https://img.shields.io/badge/MCP-1.0-green)](https://modelcontextprotocol.io/)
+
+---
+
+## 사전 요구사항
+
+- **Node.js 18+**
+- 환경변수 설정 (`.env` 파일 또는 쉘 환경):
+
+```env
+ANTHROPIC_API_KEY=sk-ant-...     # Claude API 키
+GITHUB_TOKEN=ghp_...             # GitHub Personal Access Token (repo 권한 필요)
+GITHUB_OWNER=your-username       # GitHub 유저명 (폴백용)
+GITHUB_REPO=test-repo-name       # 레포 이름 (폴백용)
+GITHUB_DEFAULT_BRANCH=main       # 기본 브랜치 (폴백용)
+```
+
+---
+
+## 빠른 시작 (3단계)
+
+### 1단계 — 초기화
+
+```bash
+# 레포 디렉토리로 이동
+cd /path/to/your/project
+
+# Vibe Orchestrator 초기화
+npx vibe-orchestrator init
+```
+
+대화형 질문에 답하면 다음 파일이 생성됩니다:
+- `CHARTER.md` — AI가 분석한 레포 컨벤션 (직접 수정해 정확하게 만드세요)
+- `.vibe/state.json` — 팀 협업 상태
+- `.vibe/config.json` — 설정
+- `.vibe/mcp.json` — AI 에이전트 연결 설정
+
+### 2단계 — AI 에이전트 연결
+
+```bash
+# Claude Code
+claude --mcp-config .vibe/mcp.json
+
+# Gemini CLI
+gemini --mcp-config .vibe/mcp.json
+```
+
+### 3단계 — 작업 시작
+
+```bash
+# CLI로 직접 작업 시작 (컨텍스트 블록 생성)
+npx vibe-orchestrator start
+
+# 또는 AI 에이전트 연결 후 vibe_start_session 도구 호출
+```
+
+---
+
+## 에이전트별 연결 방법
+
+### Claude Code
+
+```bash
+claude --mcp-config .vibe/mcp.json
+```
+
+Claude Code 내에서 `vibe_start_session`을 호출하면 자동으로 컨텍스트가 주입됩니다.
+
+### Gemini CLI
+
+```bash
+gemini --mcp-config .vibe/mcp.json
+```
+
+동일한 `.vibe/state.json`을 공유하므로 팀 현황이 실시간으로 동기화됩니다.
+
+### Cursor / 기타 MCP 지원 에디터
+
+Cursor의 MCP 설정에 `.vibe/mcp.json` 내용을 추가하세요.
+
+---
+
+## CLI 명령어 레퍼런스
+
+| 명령어 | 설명 |
+|--------|------|
+| `vibe init` | 프로젝트를 Vibe Orchestrator에 연결하고 CHARTER, state.json 생성 |
+| `vibe start` | 작업을 시작하거나 이어서 진행 (컨텍스트 블록 출력) |
+| `vibe status` | 팀 현황 출력 (진행 중 작업, 시작 가능한 작업, 최근 완료) |
+| `vibe serve` | MCP 서버 시작 (AI 에이전트 연결용, mcp.json에서 자동 실행됨) |
+
+### 옵션
+
+```bash
+vibe start --user "김지혁" --github-id "jihyuk-kim"
+```
+
+---
+
+## 생성 파일 설명
+
+### CHARTER.md
+
+AI가 레포를 분석해 자동 생성하는 팀 헌법입니다.
+
+- **이 프로젝트는 무엇인가** — 한 문단 요약
+- **기술 스택** — 감지된 언어/프레임워크
+- **폴더 구조와 역할** — 각 폴더의 역할
+- **현재 구현된 기능 맵** — 완료된 기능 테이블 (merge 시 자동 갱신)
+- **핵심 설계 결정** — 중요한 아키텍처 결정
+- **절대 하면 안 되는 것** — QA Guardian이 자동으로 검사하는 금지 패턴
+
+> 생성 후 직접 수정해 프로젝트에 맞게 정확히 채워주세요.
+
+### .vibe/state.json
+
+모든 에이전트가 공유하는 협업 상태 파일입니다.
+
+```json
+{
+  "project": "my-project",
+  "lastUpdated": "2024-01-01T00:00:00.000Z",
+  "collaborators": { "jihyuk-kim": { "name": "김지혁", ... } },
+  "activeWork": { "issueNumber": 7, "actor": "jihyuk-kim", ... },
+  "issues": [ { "number": 7, "title": "환불 기능", "stage": "work_started", ... } ],
+  "workLog": [ { "id": "log-...", "stage": "work_started", ... } ]
+}
+```
+
+### .vibe/intents/
+
+각 이슈별 의도 로그가 저장됩니다 (`{issueNumber}.json`).
+
+작업 중 결정한 사항, 거절한 방안, 경고, 다음 단계를 기록합니다.
+
+---
+
+## MCP 도구 목록 (8개)
+
+| 도구 | 설명 |
+|------|------|
+| `vibe_start_session` | 세션 시작 시 가장 먼저 호출 — CHARTER, 팀 현황, 내 상태 반환 |
+| `vibe_analyze_request` | 사용자 요청을 분석해 관련 기존 작업 항목을 찾거나 새 항목 제안 |
+| `vibe_start_work` | 작업 항목 선택 후 작업 공간(브랜치) 준비 |
+| `vibe_record_checkpoint` | 각 단계 완료 시 기록 — 다음 단계 안내 메시지 반환 |
+| `vibe_request_qa` | 코드 검토 요청 — 정적 분석 + AI 의미 검사 2단계 수행 |
+| `vibe_create_pr` | 검토 통과 후 팀에 공유 (PR 자동 생성) |
+| `vibe_request_merge_review` | 최종 반영 전 충돌 검사 — 다른 팀원 작업과 파일 겹침 확인 |
+| `vibe_execute_merge` | 최종 반영 실행 — squash merge + CHARTER 기능 맵 자동 갱신 |
+
+---
+
+## 두 에이전트 동시 사용 예시
+
+```bash
+# 터미널 A — 김지혁 (Claude Code)
+claude --mcp-config .vibe/mcp.json
+# → vibe_start_session { userName: "김지혁", githubId: "jihyuk-kim", agentName: "claude-code" }
+
+# 터미널 B — 이민수 (Gemini CLI)
+gemini --mcp-config .vibe/mcp.json
+# → vibe_start_session { userName: "이민수", githubId: "minsoo-lee", agentName: "gemini-cli" }
+
+# 두 세션이 동일한 state.json을 공유 → 팀 현황 실시간 동기화
+```
+
+---
+
+## 라이선스
+
+MIT

package/dist/ai/client.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 통합 AI 클라이언트
+ * 우선순위: proxy (로그인 토큰) > ANTHROPIC_API_KEY > OPENAI_API_KEY
+ * 모두 없으면 AI 기능 비활성화 (graceful degradation)
+ */
+export type AIProvider = 'proxy' | 'anthropic' | 'openai' | null;
+export type AITier = 'smart' | 'fast';
+export declare function getStoredToken(): string | null;
+export declare function getAIProvider(): AIProvider;
+export declare function callAI(params: {
+    system: string;
+    user: string;
+    tier?: AITier;
+    maxTokens?: number;
+}): Promise<string>;

package/dist/ai/client.js

@@ -0,0 +1,89 @@
+/**
+ * 통합 AI 클라이언트
+ * 우선순위: proxy (로그인 토큰) > ANTHROPIC_API_KEY > OPENAI_API_KEY
+ * 모두 없으면 AI 기능 비활성화 (graceful degradation)
+ */
+import { readAuthData } from '../cli/commands/auth.js';
+const VIBE_PROXY_URL = process.env.VIBE_API_URL ?? 'https://vibeorchestratorserver.vercel.app';
+const MODELS = {
+    anthropic: {
+        smart: 'claude-sonnet-4-6',
+        fast: 'claude-haiku-4-5-20251001',
+    },
+    openai: {
+        smart: 'gpt-4o',
+        fast: 'gpt-4o-mini',
+    },
+};
+export function getStoredToken() {
+    try {
+        const data = readAuthData();
+        return data?.token ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+export function getAIProvider() {
+    if (getStoredToken())
+        return 'proxy';
+    if (process.env.ANTHROPIC_API_KEY)
+        return 'anthropic';
+    if (process.env.OPENAI_API_KEY)
+        return 'openai';
+    return null;
+}
+export async function callAI(params) {
+    const { system, user, tier = 'fast', maxTokens = 1024 } = params;
+    const provider = getAIProvider();
+    if (!provider) {
+        throw new Error('AI를 사용하려면 로그인이 필요합니다.\n  vibe auth login');
+    }
+    // 1. Proxy (operator server — user logged in)
+    if (provider === 'proxy') {
+        const token = getStoredToken();
+        const res = await fetch(`${VIBE_PROXY_URL}/api/ai/complete`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify({ system, user, tier, maxTokens }),
+        });
+        if (!res.ok) {
+            const err = (await res.json().catch(() => ({ error: res.statusText })));
+            if (res.status === 401) {
+                throw new Error('토큰이 만료됐습니다. 다시 로그인하세요:\n  vibe auth login');
+            }
+            throw new Error(err.error ?? `프록시 서버 오류 (${res.status})`);
+        }
+        const data = (await res.json());
+        return data.text;
+    }
+    // 2. Direct Anthropic (operator running locally)
+    if (provider === 'anthropic') {
+        const { default: Anthropic } = await import('@anthropic-ai/sdk');
+        const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+        const response = await client.messages.create({
+            model: MODELS.anthropic[tier],
+            max_tokens: maxTokens,
+            system,
+            messages: [{ role: 'user', content: user }],
+        });
+        const content = response.content[0];
+        return content.type === 'text' ? content.text : '';
+    }
+    // 3. Direct OpenAI (operator running locally)
+    const { default: OpenAI } = await import('openai');
+    const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+    const response = await client.chat.completions.create({
+        model: MODELS.openai[tier],
+        max_tokens: maxTokens,
+        messages: [
+            { role: 'system', content: system },
+            { role: 'user', content: user },
+        ],
+    });
+    return response.choices[0]?.message?.content ?? '';
+}
+//# sourceMappingURL=client.js.map

package/dist/charter/generator.d.ts

@@ -0,0 +1,10 @@
+import type { IssueState } from '../state/types.js';
+export declare function generateCharter(params: {
+    projectName: string;
+    owner: string;
+    repo: string;
+    readme: string | null;
+    packageJson: string | null;
+    rootStructure: string[];
+    openIssues: IssueState[];
+}): Promise<string>;

package/dist/charter/generator.js

@@ -0,0 +1,41 @@
+import { callAI } from '../ai/client.js';
+export async function generateCharter(params) {
+    const { projectName, owner, repo, readme, packageJson, rootStructure, openIssues } = params;
+    const userContent = `
+프로젝트 이름: ${projectName}
+레포: ${owner}/${repo}
+
+루트 구조:
+${rootStructure.join('\n')}
+
+README:
+${readme ?? '(없음)'}
+
+package.json:
+${packageJson ?? '(없음)'}
+
+열린 이슈 목록:
+${openIssues.length > 0 ? openIssues.map((i) => `- #${i.number} ${i.title}`).join('\n') : '(없음)'}
+`.trim();
+    const text = await callAI({
+        system: `당신은 소프트웨어 팀의 기술 리드입니다.
+GitHub 레포 정보를 분석하여 팀 협업을 위한 CHARTER.md 마크다운을 작성하세요.
+
+반드시 다음 섹션을 포함하세요:
+1. 이 프로젝트는 무엇인가 (한 문단)
+2. 기술 스택 (감지된 언어/프레임워크 기반)
+3. 폴더 구조와 역할 (루트 구조 기반 추론)
+4. 현재 구현된 기능 맵 (빈 마크다운 테이블로 시작, 헤더: | 기능 | 위치 | 담당 | 이슈 | 상태 |)
+5. 핵심 설계 결정 (감지된 패턴 기반, 없으면 placeholder)
+6. 절대 하면 안 되는 것 (구체적인 금지 패턴, [Guardian이 자동 검사] 태그 포함)
+
+추상적 원칙보다 "이 패턴은 금지"처럼 구체적이고 검사 가능한 규칙을 작성하세요.
+정보가 부족한 섹션은 <!-- TODO: 채워주세요 --> 플레이스홀더를 사용하세요.
+마크다운만 반환하세요 (코드블록 감싸지 말 것).`,
+        user: userContent,
+        tier: 'smart',
+        maxTokens: 4096,
+    });
+    return text || '# CHARTER\n\n<!-- TODO: 채워주세요 -->';
+}
+//# sourceMappingURL=generator.js.map

package/dist/charter/updater.d.ts

@@ -0,0 +1,10 @@
+export declare function updateFeatureMap(repoPath: string, feature: {
+    title: string;
+    path: string;
+    assignee: string;
+    issueNumber: number;
+}): Promise<void>;
+export declare function extractForbiddenPatterns(charter: string): Array<{
+    description: string;
+    patternString?: string;
+}>;

package/dist/charter/updater.js

@@ -0,0 +1,41 @@
+import { readCharter, } from '../state/reader.js';
+import { writeCharter } from '../state/writer.js';
+export async function updateFeatureMap(repoPath, feature) {
+    let charter = await readCharter(repoPath);
+    const date = new Date().toLocaleDateString('ko-KR');
+    const newRow = `| ${feature.title} | ${feature.path} | ${feature.assignee} | #${feature.issueNumber} | ${date} |`;
+    // 기능 맵 테이블 찾기
+    const tableHeaderPattern = /\|\s*기능\s*\|\s*위치\s*\|\s*담당\s*\|\s*이슈\s*\|\s*상태\s*\|/;
+    if (tableHeaderPattern.test(charter)) {
+        // 테이블 구분선 다음 줄 찾아서 행 추가
+        charter = charter.replace(/((\|\s*[-:]+\s*\|)+\s*\n)/, `$1${newRow}\n`);
+    }
+    else {
+        // 섹션 없으면 전체 추가
+        const featureSection = `\n## 현재 구현된 기능 맵\n\n| 기능 | 위치 | 담당 | 이슈 | 상태 |\n|------|------|------|------|------|\n${newRow}\n`;
+        charter += featureSection;
+    }
+    await writeCharter(repoPath, charter);
+}
+export function extractForbiddenPatterns(charter) {
+    const results = [];
+    // "절대 하면 안 되는 것" 섹션 찾기
+    const sectionMatch = charter.match(/##\s*절대\s*하면\s*안\s*되는\s*것[\s\S]*?(?=\n##\s|\n#\s|$)/);
+    if (!sectionMatch)
+        return results;
+    const section = sectionMatch[0];
+    const lines = section.split('\n').filter((line) => line.trim().startsWith('-'));
+    for (const line of lines) {
+        const text = line.replace(/^[\s-]+/, '').trim();
+        if (!text)
+            continue;
+        // 코드 패턴 추출 시도 (backtick으로 감싸진 패턴)
+        const codeMatch = text.match(/`([^`]+)`/);
+        results.push({
+            description: text,
+            patternString: codeMatch ? codeMatch[1] : undefined,
+        });
+    }
+    return results;
+}
+//# sourceMappingURL=updater.js.map

package/dist/cli/commands/auth.d.ts

@@ -0,0 +1,12 @@
+interface AuthData {
+    token: string;
+    user: {
+        login: string;
+        name: string;
+    };
+    expiresAt: string;
+    githubToken?: string | null;
+}
+export declare function readAuthData(): AuthData | null;
+export declare function authCommand(action: string): Promise<void>;
+export {};

package/dist/cli/commands/auth.js

@@ -0,0 +1,180 @@
+import http from 'http';
+import os from 'os';
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+const AUTH_FILE = path.join(os.homedir(), '.vibe', 'auth.json');
+const PROXY_URL = process.env.VIBE_API_URL ?? 'https://vibeorchestratorserver.vercel.app';
+const CALLBACK_PORT = 7777;
+/* ── token helpers ─────────────────────────────────────────────── */
+export function readAuthData() {
+    try {
+        const raw = fs.readFileSync(AUTH_FILE, 'utf-8');
+        const data = JSON.parse(raw);
+        if (new Date(data.expiresAt) < new Date())
+            return null; // expired
+        return data;
+    }
+    catch {
+        return null;
+    }
+}
+function saveAuthData(data) {
+    const dir = path.dirname(AUTH_FILE);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(AUTH_FILE, JSON.stringify(data, null, 2), 'utf-8');
+}
+function deleteAuthData() {
+    try {
+        fs.unlinkSync(AUTH_FILE);
+    }
+    catch {
+        // already gone
+    }
+}
+/** Decode JWT payload without verifying signature (CLI only needs expiry/user info) */
+function decodeJwtPayload(token) {
+    try {
+        const parts = token.split('.');
+        if (parts.length !== 3)
+            return null;
+        const payload = Buffer.from(parts[1], 'base64url').toString('utf-8');
+        return JSON.parse(payload);
+    }
+    catch {
+        return null;
+    }
+}
+/* ── open browser cross-platform ───────────────────────────────── */
+function openBrowser(url) {
+    const cmd = process.platform === 'win32' ? `start "" "${url}"` :
+        process.platform === 'darwin' ? `open "${url}"` :
+            `xdg-open "${url}"`;
+    try {
+        execSync(cmd, { stdio: 'ignore' });
+    }
+    catch {
+        console.log(chalk.yellow(`브라우저를 열 수 없습니다. 직접 아래 URL을 여세요:\n${url}`));
+    }
+}
+/* ── login flow ─────────────────────────────────────────────────── */
+async function loginFlow() {
+    const state = Math.random().toString(36).slice(2) + Date.now().toString(36);
+    console.log(chalk.cyan('\n🔐 Vibe Orchestrator 로그인\n'));
+    return new Promise((resolve, reject) => {
+        let resolved = false;
+        // 1. Start local callback server
+        const server = http.createServer((req, res) => {
+            const url = new URL(req.url ?? '/', `http://localhost:${CALLBACK_PORT}`);
+            if (url.pathname !== '/callback') {
+                res.writeHead(404);
+                res.end();
+                return;
+            }
+            const receivedToken = url.searchParams.get('token');
+            const receivedState = url.searchParams.get('state');
+            // Validate state to prevent CSRF
+            if (receivedState !== state || !receivedToken) {
+                res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
+                res.end('<h1>인증 실패</h1><p>잘못된 요청입니다. 다시 시도해주세요.</p>');
+                return;
+            }
+            // Decode payload
+            const payload = decodeJwtPayload(receivedToken);
+            if (!payload) {
+                res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
+                res.end('<h1>인증 실패</h1><p>잘못된 토큰입니다.</p>');
+                return;
+            }
+            // Save token
+            const authData = {
+                token: receivedToken,
+                user: { login: payload.login ?? payload.sub, name: payload.name },
+                expiresAt: new Date(payload.exp * 1000).toISOString(),
+                githubToken: payload.githubToken ?? null,
+            };
+            saveAuthData(authData);
+            // Respond to browser — redirect to /callback page
+            res.writeHead(302, { Location: `${PROXY_URL}/callback` });
+            res.end();
+            // Shutdown server and resolve
+            if (!resolved) {
+                resolved = true;
+                clearTimeout(timeout);
+                server.close();
+                console.log(chalk.green(`\n✅ 로그인 완료! 환영합니다, ${authData.user.name} (@${authData.user.login})\n`));
+                resolve();
+            }
+        });
+        server.listen(CALLBACK_PORT, () => {
+            // 2. Open browser
+            const loginUrl = `${PROXY_URL}/login?port=${CALLBACK_PORT}&state=${encodeURIComponent(state)}`;
+            console.log(chalk.gray(`브라우저가 열립니다... (${loginUrl})\n`));
+            openBrowser(loginUrl);
+            console.log(chalk.gray('GitHub 로그인을 완료해주세요. 대기 중...\n'));
+        });
+        server.on('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                reject(new Error(`포트 ${CALLBACK_PORT}이 이미 사용 중입니다. 잠시 후 다시 시도해주세요.`));
+            }
+            else {
+                reject(err);
+            }
+        });
+        // Timeout after 5 minutes
+        const timeout = setTimeout(() => {
+            if (!resolved) {
+                resolved = true;
+                server.close();
+                reject(new Error('로그인 시간이 초과됐습니다 (5분). 다시 시도해주세요.'));
+            }
+        }, 5 * 60 * 1000);
+    });
+}
+/* ── public command ─────────────────────────────────────────────── */
+export async function authCommand(action) {
+    switch (action) {
+        case 'login': {
+            const existing = readAuthData();
+            if (existing) {
+                console.log(chalk.yellow(`이미 로그인되어 있습니다: @${existing.user.login}\n` +
+                    `만료: ${new Date(existing.expiresAt).toLocaleString('ko-KR')}\n\n` +
+                    `재로그인하려면: vibe auth logout 후 vibe auth login`));
+                return;
+            }
+            await loginFlow();
+            process.exit(0);
+        }
+        case 'logout': {
+            const data = readAuthData();
+            deleteAuthData();
+            if (data) {
+                console.log(chalk.green(`👋 @${data.user.login} 로그아웃 완료.`));
+            }
+            else {
+                console.log(chalk.yellow('로그인 상태가 아닙니다.'));
+            }
+            break;
+        }
+        case 'status': {
+            const data = readAuthData();
+            if (!data) {
+                console.log(chalk.yellow('\n로그인되어 있지 않습니다.\n  vibe auth login\n'));
+                return;
+            }
+            const expiresAt = new Date(data.expiresAt);
+            const daysLeft = Math.ceil((expiresAt.getTime() - Date.now()) / 86400000);
+            console.log(chalk.green(`
+✅ 로그인 상태
+  사용자: ${data.user.name} (@${data.user.login})
+  만료: ${expiresAt.toLocaleString('ko-KR')} (${daysLeft}일 남음)
+`));
+            break;
+        }
+        default:
+            console.log(chalk.red(`알 수 없는 액션: ${action}\n사용법: vibe auth <login|logout|status>`));
+    }
+}
+//# sourceMappingURL=auth.js.map

package/dist/cli/commands/connect.d.ts

@@ -0,0 +1 @@
+export declare function connectCommand(cwd: string): Promise<void>;