vibe-collab 0.1.0

package/dist/mcp/tools/requestQA.d.ts

@@ -0,0 +1,6 @@
+import type { Actor } from '../../state/types.js';
+export declare function requestQA(repoPath: string, input: {
+    issueNumber: number;
+    actor: Actor;
+    changedFiles: string[];
+}): Promise<string>;

package/dist/mcp/tools/requestQA.js

@@ -0,0 +1,147 @@
+import { callAI, getAIProvider } from '../../ai/client.js';
+import { readState, readCharter, readConfig } from '../../state/reader.js';
+import { getFileContentsByPaths } from '../../github/files.js';
+import { extractForbiddenPatterns } from '../../charter/updater.js';
+const STATIC_RULES = [
+    {
+        rule: 'no-any-type',
+        pattern: /:\s*any[\s;,)>]/g,
+        severity: 'error',
+        description: '타입이 지정되지 않은 코드가 있습니다',
+        suggestion: '구체적인 타입을 지정해주세요',
+    },
+    {
+        rule: 'no-hardcoded-secrets',
+        pattern: /(api_key|apikey|secret|password|token)\s*[=:]\s*["'][^"'$\s]{8,}["']/gi,
+        severity: 'error',
+        description: '비밀 코드가 직접 작성돼 있습니다 (보안 위험)',
+        suggestion: '환경변수를 사용해주세요',
+    },
+    {
+        rule: 'no-console-log',
+        pattern: /console\.log\(/g,
+        severity: 'warning',
+        description: '기록용 코드가 남아있습니다',
+        suggestion: 'logger를 사용하거나 제거해주세요',
+    },
+    {
+        rule: 'no-sync-io',
+        pattern: /(?:fs\.)?readFileSync|writeFileSync/g,
+        severity: 'warning',
+        description: '처리 속도를 저하시키는 방식이 사용됐습니다',
+        suggestion: '비동기 방식을 사용해주세요',
+    },
+];
+export async function requestQA(repoPath, input) {
+    const { issueNumber, changedFiles } = input;
+    const [state, charter, config] = await Promise.all([
+        readState(repoPath),
+        readCharter(repoPath),
+        readConfig(repoPath),
+    ]);
+    const issue = state.issues.find((i) => i.number === issueNumber);
+    const branchName = issue?.branch;
+    if (!config || !branchName) {
+        return JSON.stringify({
+            result: {
+                passed: false,
+                violations: [],
+                summary: 'config 또는 브랜치 정보가 없습니다.',
+            },
+        });
+    }
+    const { owner, repo } = config;
+    // 파일 내용 가져오기
+    const fileContents = await getFileContentsByPaths(owner, repo, changedFiles, branchName);
+    const layer1Violations = [];
+    const filesWithErrors = new Set();
+    // 계층 1 — 정적 분석
+    for (const { path: filePath, content } of fileContents) {
+        for (const rule of STATIC_RULES) {
+            if (rule.pattern.test(content)) {
+                layer1Violations.push({
+                    severity: rule.severity,
+                    layer: 'static',
+                    rule: rule.rule,
+                    file: filePath,
+                    description: rule.description,
+                    suggestion: rule.suggestion,
+                });
+                if (rule.severity === 'error') {
+                    filesWithErrors.add(filePath);
+                }
+            }
+            rule.pattern.lastIndex = 0;
+        }
+        // CHARTER 금지 패턴 동적 검사
+        const forbiddenPatterns = extractForbiddenPatterns(charter);
+        for (const fp of forbiddenPatterns) {
+            if (fp.patternString) {
+                try {
+                    const regex = new RegExp(fp.patternString, 'gi');
+                    if (regex.test(content)) {
+                        layer1Violations.push({
+                            severity: 'error',
+                            layer: 'static',
+                            rule: 'charter-violation',
+                            file: filePath,
+                            description: `CHARTER 위반: ${fp.description}`,
+                            suggestion: '해당 패턴을 제거해주세요',
+                        });
+                        filesWithErrors.add(filePath);
+                    }
+                }
+                catch {
+                    // 유효하지 않은 정규식 무시
+                }
+            }
+        }
+    }
+    // 계층 2 — LLM 의미 검사 (layer1에서 error 없는 파일만, AI 있을 때만)
+    const layer2Violations = [];
+    const cleanFiles = fileContents.filter((f) => !filesWithErrors.has(f.path));
+    if (cleanFiles.length > 0 && charter && getAIProvider()) {
+        const forbiddenSection = charter.match(/##\s*절대\s*하면\s*안\s*되는\s*것[\s\S]*?(?=\n##\s|\n#\s|$)/)?.[0] ?? '';
+        if (forbiddenSection) {
+            try {
+                const codeContent = cleanFiles
+                    .map((f) => `### ${f.path}\n${f.content}`)
+                    .join('\n\n');
+                const raw = await callAI({
+                    system: '다음 코드가 CHARTER 규칙을 위반하는지 검사하라. 반드시 순수 JSON 배열만 반환 (마크다운 없이). 위반 없으면 []. 각 항목: { "rule": string, "file": string, "description": string, "suggestion": string }',
+                    user: `CHARTER 규칙:\n${forbiddenSection}\n\n코드:\n${codeContent}`,
+                    tier: 'fast',
+                    maxTokens: 1024,
+                });
+                const clean = raw.replace(/```json\n?/g, '').replace(/```\n?/g, '').trim();
+                const llmViolations = JSON.parse(clean);
+                for (const v of llmViolations) {
+                    layer2Violations.push({
+                        severity: 'warning',
+                        layer: 'llm',
+                        rule: v.rule,
+                        file: v.file,
+                        description: v.description,
+                        suggestion: v.suggestion,
+                    });
+                }
+            }
+            catch {
+                // LLM 검사 실패 시 빈 배열
+            }
+        }
+    }
+    const allViolations = [...layer1Violations, ...layer2Violations];
+    const passed = !allViolations.some((v) => v.severity === 'error');
+    const errorCount = allViolations.filter((v) => v.severity === 'error').length;
+    const warningCount = allViolations.filter((v) => v.severity === 'warning').length;
+    const result = {
+        passed,
+        violations: allViolations,
+        summary: passed
+            ? `검토 통과 (경고 ${warningCount}개)`
+            : `검토 실패 (오류 ${errorCount}개, 경고 ${warningCount}개)`,
+    };
+    return JSON.stringify({ result });
+}
+//# sourceMappingURL=requestQA.js.map

package/dist/mcp/tools/startSession.d.ts

@@ -0,0 +1,5 @@
+export declare function startSession(repoPath: string, input: {
+    userName: string;
+    githubId: string;
+    agentName: string;
+}): Promise<string>;

package/dist/mcp/tools/startSession.js

@@ -0,0 +1,97 @@
+import { readCharter, readState } from '../../state/reader.js';
+import { registerCollaborator, appendWorkLog } from '../../state/writer.js';
+function stageToKorean(stage) {
+    const map = {
+        not_started: '시작 전',
+        context_loaded: '맥락 로드됨',
+        work_started: '작업 중',
+        code_complete: '코드 완료',
+        qa_passed: '검토 통과, 팀 공유 대기',
+        qa_failed: '검토 실패, 재작업 중',
+        pr_created: '팀 공유됨, 최종 반영 대기',
+        merge_approved: '최종 반영 승인됨',
+        merge_rejected: '최종 반영 거절됨',
+        merge_completed: '완료',
+    };
+    return map[stage] ?? stage;
+}
+export async function startSession(repoPath, input) {
+    const { userName, githubId, agentName } = input;
+    // 1. CHARTER + state 읽기
+    const [charter, state] = await Promise.all([
+        readCharter(repoPath),
+        readState(repoPath),
+    ]);
+    // 2. collaborator 등록/갱신
+    await registerCollaborator(repoPath, githubId, {
+        name: userName,
+        githubId,
+        lastActive: new Date().toISOString(),
+    });
+    // 3. 이슈 분류
+    const inProgressIssues = state.issues.filter((i) => i.status === 'in_progress' || i.status === 'pr_created');
+    const availableIssues = state.issues.filter((i) => i.status === 'open' && !i.assignee);
+    const recentMerged = state.issues
+        .filter((i) => i.status === 'merged')
+        .slice(-3);
+    // 4. 일시중단 작업 확인
+    const pausedWork = state.activeWork?.paused && state.activeWork.actor === githubId
+        ? state.activeWork
+        : null;
+    const pausedIssue = pausedWork
+        ? state.issues.find((i) => i.number === pausedWork.issueNumber)
+        : null;
+    // 5. workLog에 context_loaded 추가
+    await appendWorkLog(repoPath, {
+        actor: { name: userName, githubId, agent: agentName },
+        stage: 'context_loaded',
+        action: 'start_session',
+        message: `세션 시작: ${userName} (${githubId}) - ${agentName}`,
+    });
+    const inProgressText = inProgressIssues.length > 0
+        ? inProgressIssues
+            .map((i) => `  #${i.number} "${i.title}" — ${i.assignee ?? '미배정'} (${stageToKorean(i.stage)})`)
+            .join('\n')
+        : '  없음';
+    const availableText = availableIssues.length > 0
+        ? availableIssues.map((i) => `  #${i.number} "${i.title}"`).join('\n')
+        : '  없음';
+    const mergedText = recentMerged.length > 0
+        ? recentMerged.map((i) => `  #${i.number} "${i.title}" — ${i.assignee ?? '알 수 없음'}`).join('\n')
+        : '  없음';
+    const pausedText = pausedIssue
+        ? `⏸ 일시중단된 작업: #${pausedIssue.number} — "${pausedIssue.title}" (${stageToKorean(pausedWork.stage)})`
+        : '일시중단된 작업 없음';
+    return `=== VIBE ORCHESTRATOR 컨텍스트 로드 완료 ===
+
+[프로젝트]
+이름: ${state.project || '(미설정)'}
+최종 업데이트: ${state.lastUpdated || '(없음)'}
+
+[레포 헌법 — CHARTER]
+${charter || '(CHARTER 없음 — vibe init을 먼저 실행해주세요)'}
+
+[팀 현황]
+진행 중:
+${inProgressText}
+
+시작 가능한 작업:
+${availableText}
+
+최근 완료:
+${mergedText}
+
+[내 상태]
+사용자: ${userName} (${githubId})
+에이전트: ${agentName}
+${pausedText}
+
+[지시사항]
+- 모든 코드는 CHARTER 규칙을 반드시 준수할 것
+- 작업 시작 전 반드시 vibe_analyze_request를 호출할 것
+- 각 단계 완료 시 vibe_record_checkpoint를 호출할 것
+- 사용자에게 체크포인트 메시지를 그대로 전달하고 확인을 받을 것
+- Issue, PR, Merge, Branch 같은 기술 용어 절대 사용 금지
+==========================================`;
+}
+//# sourceMappingURL=startSession.js.map

package/dist/mcp/tools/startWork.d.ts

@@ -0,0 +1,7 @@
+import type { Actor } from '../../state/types.js';
+export declare function startWork(repoPath: string, input: {
+    issueNumber: number;
+    actor: Actor;
+    createNew: boolean;
+    newIssueTitle?: string;
+}): Promise<string>;

package/dist/mcp/tools/startWork.js

@@ -0,0 +1,97 @@
+import { readState, readIntentLog, readConfig } from '../../state/reader.js';
+import { writeState, setActiveWork, updateIssueStage, appendWorkLog, } from '../../state/writer.js';
+import { branchExists, createBranch, getRecentCommits, getChangedFiles } from '../../github/branches.js';
+import { createIssue } from '../../github/issues.js';
+function slugify(title) {
+    return (title
+        .toLowerCase()
+        .replace(/[가-힣]/g, '')
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '')
+        .substring(0, 30) || 'task');
+}
+export async function startWork(repoPath, input) {
+    const { actor, createNew, newIssueTitle } = input;
+    let { issueNumber } = input;
+    const config = await readConfig(repoPath);
+    if (!config) {
+        return JSON.stringify({ error: 'config.json이 없습니다. vibe init을 먼저 실행해주세요.' });
+    }
+    const { owner, repo, defaultBranch } = config;
+    // 1. 새 이슈 생성
+    let issueTitle = '';
+    if (createNew && newIssueTitle) {
+        issueNumber = await createIssue(owner, repo, newIssueTitle, '');
+        issueTitle = newIssueTitle;
+        // state에 추가
+        const st = await readState(repoPath);
+        st.issues.push({
+            number: issueNumber,
+            title: issueTitle,
+            status: 'open',
+            branch: null,
+            assignee: null,
+            stage: 'not_started',
+            prNumber: null,
+            intentLogPath: null,
+        });
+        await writeState(repoPath, st);
+    }
+    else {
+        const st = await readState(repoPath);
+        const issue = st.issues.find((i) => i.number === issueNumber);
+        issueTitle = issue?.title ?? `이슈 #${issueNumber}`;
+    }
+    // 2. 브랜치명 생성
+    const branchName = `vibe/${actor.githubId}/${issueNumber}/${slugify(issueTitle)}`;
+    // 3. 브랜치 없으면 생성
+    const exists = await branchExists(owner, repo, branchName);
+    if (!exists) {
+        await createBranch(owner, repo, branchName, defaultBranch);
+    }
+    // 4. 기존 커밋/변경 파일
+    const [commits, changedFiles] = await Promise.all([
+        getRecentCommits(owner, repo, branchName, 5),
+        getChangedFiles(owner, repo, branchName, defaultBranch),
+    ]);
+    const existingChanges = commits.length > 0
+        ? `이미 ${commits.length}개 저장이 있습니다:\n${commits.map((c) => `  · ${c}`).join('\n')}`
+        : '이전 저장 없음';
+    // 5. intent 로그
+    const intentLog = await readIntentLog(repoPath, issueNumber);
+    const intentText = intentLog
+        ? `결정 사항: ${intentLog.decided.join(', ')}\n거절된 방안: ${intentLog.rejected.join(', ')}`
+        : '없음 (새 작업)';
+    // 6. state 업데이트
+    await setActiveWork(repoPath, {
+        issueNumber,
+        actor: actor.githubId,
+        stage: 'work_started',
+        startedAt: new Date().toISOString(),
+        paused: false,
+        pausedAt: null,
+        retryCount: 0,
+    });
+    await updateIssueStage(repoPath, issueNumber, {
+        status: 'in_progress',
+        branch: branchName,
+        assignee: actor.githubId,
+        stage: 'work_started',
+    });
+    // 7. workLog
+    await appendWorkLog(repoPath, {
+        actor,
+        stage: 'work_started',
+        issueNumber,
+        action: 'start_work',
+        message: `작업 시작: #${issueNumber} "${issueTitle}"`,
+        filesChanged: changedFiles,
+    });
+    return JSON.stringify({
+        branchName,
+        existingChanges,
+        intentLog: intentText,
+        readyMessage: `작업 공간이 준비됐습니다.\n브랜치: ${branchName}\n\n코드 작성을 시작하세요.`,
+    });
+}
+//# sourceMappingURL=startWork.js.map

package/dist/state/reader.d.ts

@@ -0,0 +1,5 @@
+import type { VibeState, IntentLog, VibeConfig } from './types.js';
+export declare function readState(repoPath: string): Promise<VibeState>;
+export declare function readIntentLog(repoPath: string, issueNumber: number): Promise<IntentLog | null>;
+export declare function readCharter(repoPath: string): Promise<string>;
+export declare function readConfig(repoPath: string): Promise<VibeConfig | null>;

package/dist/state/reader.js

@@ -0,0 +1,50 @@
+import { readFile } from 'fs/promises';
+import path from 'path';
+const DEFAULT_STATE = {
+    project: '',
+    lastUpdated: '',
+    collaborators: {},
+    activeWork: null,
+    issues: [],
+    workLog: [],
+};
+export async function readState(repoPath) {
+    const statePath = path.join(repoPath, '.vibe', 'state.json');
+    try {
+        const raw = await readFile(statePath, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return { ...DEFAULT_STATE };
+    }
+}
+export async function readIntentLog(repoPath, issueNumber) {
+    const logPath = path.join(repoPath, '.vibe', 'intents', `${issueNumber}.json`);
+    try {
+        const raw = await readFile(logPath, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export async function readCharter(repoPath) {
+    const charterPath = path.join(repoPath, 'CHARTER.md');
+    try {
+        return await readFile(charterPath, 'utf-8');
+    }
+    catch {
+        return '';
+    }
+}
+export async function readConfig(repoPath) {
+    const configPath = path.join(repoPath, '.vibe', 'config.json');
+    try {
+        const raw = await readFile(configPath, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=reader.js.map

package/dist/state/types.d.ts

@@ -0,0 +1,83 @@
+export type Stage = 'not_started' | 'context_loaded' | 'work_started' | 'code_complete' | 'qa_passed' | 'qa_failed' | 'pr_created' | 'merge_approved' | 'merge_rejected' | 'merge_completed';
+export interface Actor {
+    name: string;
+    githubId: string;
+    agent: string;
+}
+export interface WorkLogEntry {
+    id: string;
+    timestamp: string;
+    actor: Actor;
+    stage: Stage;
+    issueNumber?: number;
+    action: string;
+    message: string;
+    filesChanged?: string[];
+    retryCount?: number;
+}
+export interface IssueState {
+    number: number;
+    title: string;
+    status: 'open' | 'in_progress' | 'pr_created' | 'merged' | 'closed';
+    branch: string | null;
+    assignee: string | null;
+    stage: Stage;
+    prNumber: number | null;
+    intentLogPath: string | null;
+}
+export interface ActiveWork {
+    issueNumber: number;
+    actor: string;
+    stage: Stage;
+    startedAt: string;
+    paused: boolean;
+    pausedAt: string | null;
+    retryCount: number;
+}
+export interface Collaborator {
+    name: string;
+    githubId: string;
+    lastActive: string;
+}
+export interface VibeState {
+    project: string;
+    lastUpdated: string;
+    collaborators: Record<string, Collaborator>;
+    activeWork: ActiveWork | null;
+    issues: IssueState[];
+    workLog: WorkLogEntry[];
+}
+export interface QAViolation {
+    severity: 'error' | 'warning';
+    layer: 'static' | 'llm';
+    rule: string;
+    file: string;
+    description: string;
+    suggestion?: string;
+}
+export interface QAResult {
+    passed: boolean;
+    violations: QAViolation[];
+    summary: string;
+}
+export interface MergeReviewResult {
+    approved: boolean;
+    reason: string;
+    conflictingIssues: number[];
+    riskyFiles: string[];
+}
+export interface IntentLog {
+    issueNumber: number;
+    author: Actor;
+    timestamp: string;
+    decided: string[];
+    rejected: string[];
+    warnings: string[];
+    nextSteps: string[];
+}
+export interface VibeConfig {
+    owner: string;
+    repo: string;
+    defaultBranch: string;
+    protectedPaths: string[];
+}

package/dist/state/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/state/writer.d.ts

@@ -0,0 +1,10 @@
+import type { VibeState, WorkLogEntry, IssueState, ActiveWork, Collaborator, IntentLog, VibeConfig } from './types.js';
+export declare function ensureVibeDir(repoPath: string): Promise<void>;
+export declare function writeState(repoPath: string, state: VibeState): Promise<void>;
+export declare function appendWorkLog(repoPath: string, entry: Omit<WorkLogEntry, 'id' | 'timestamp'>): Promise<void>;
+export declare function updateIssueStage(repoPath: string, issueNumber: number, updates: Partial<IssueState>): Promise<void>;
+export declare function setActiveWork(repoPath: string, work: ActiveWork | null): Promise<void>;
+export declare function registerCollaborator(repoPath: string, key: string, collaborator: Collaborator): Promise<void>;
+export declare function saveIntentLog(repoPath: string, log: IntentLog): Promise<void>;
+export declare function writeConfig(repoPath: string, config: VibeConfig): Promise<void>;
+export declare function writeCharter(repoPath: string, content: string): Promise<void>;

package/dist/state/writer.js

@@ -0,0 +1,82 @@
+import { mkdir, writeFile } from 'fs/promises';
+import path from 'path';
+import { readState } from './reader.js';
+async function withRetry(fn, retries = 3) {
+    for (let i = 0; i < retries; i++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            if (i === retries - 1)
+                throw error;
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+    }
+    throw new Error('재시도 횟수 초과');
+}
+export async function ensureVibeDir(repoPath) {
+    await mkdir(path.join(repoPath, '.vibe', 'intents'), { recursive: true });
+}
+export async function writeState(repoPath, state) {
+    await ensureVibeDir(repoPath);
+    const updated = { ...state, lastUpdated: new Date().toISOString() };
+    const statePath = path.join(repoPath, '.vibe', 'state.json');
+    await withRetry(() => writeFile(statePath, JSON.stringify(updated, null, 2), 'utf-8'));
+}
+export async function appendWorkLog(repoPath, entry) {
+    const state = await readState(repoPath);
+    const newEntry = {
+        ...entry,
+        id: `log-${Date.now()}`,
+        timestamp: new Date().toISOString(),
+    };
+    state.workLog.push(newEntry);
+    await writeState(repoPath, state);
+}
+export async function updateIssueStage(repoPath, issueNumber, updates) {
+    const state = await readState(repoPath);
+    const idx = state.issues.findIndex((i) => i.number === issueNumber);
+    if (idx !== -1) {
+        state.issues[idx] = { ...state.issues[idx], ...updates };
+    }
+    else {
+        // 이슈가 없으면 새로 추가
+        state.issues.push({
+            number: issueNumber,
+            title: '',
+            status: 'open',
+            branch: null,
+            assignee: null,
+            stage: 'not_started',
+            prNumber: null,
+            intentLogPath: null,
+            ...updates,
+        });
+    }
+    await writeState(repoPath, state);
+}
+export async function setActiveWork(repoPath, work) {
+    const state = await readState(repoPath);
+    state.activeWork = work;
+    await writeState(repoPath, state);
+}
+export async function registerCollaborator(repoPath, key, collaborator) {
+    const state = await readState(repoPath);
+    state.collaborators[key] = collaborator;
+    await writeState(repoPath, state);
+}
+export async function saveIntentLog(repoPath, log) {
+    await ensureVibeDir(repoPath);
+    const logPath = path.join(repoPath, '.vibe', 'intents', `${log.issueNumber}.json`);
+    await writeFile(logPath, JSON.stringify(log, null, 2), 'utf-8');
+}
+export async function writeConfig(repoPath, config) {
+    await ensureVibeDir(repoPath);
+    const configPath = path.join(repoPath, '.vibe', 'config.json');
+    await writeFile(configPath, JSON.stringify(config, null, 2), 'utf-8');
+}
+export async function writeCharter(repoPath, content) {
+    const charterPath = path.join(repoPath, 'CHARTER.md');
+    await writeFile(charterPath, content, 'utf-8');
+}
+//# sourceMappingURL=writer.js.map

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "vibe-collab",
+  "version": "0.1.0",
+  "description": "누가 어떤 AI를 써도, 항상 한 팀처럼 작동하는 바이브 코딩 협업 도구",
+  "type": "module",
+  "bin": {
+    "vibe": "./dist/cli/index.js",
+    "vibe-orchestrator": "./dist/cli/index.js"
+  },
+  "files": [
+    "dist/**",
+    "!dist/**/*.map",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/cli/index.ts",
+    "typecheck": "tsc --noEmit",
+    "start": "node dist/cli/index.js"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.39.0",
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@octokit/rest": "^21.0.0",
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "dotenv": "^16.4.0",
+    "inquirer": "^10.2.0",
+    "openai": "^4.77.0",
+    "ora": "^8.1.0",
+    "uipro-cli": "^2.2.3"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.7",
+    "@types/node": "^22.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0"
+  }
+}