vibe-collab 0.1.0

package/dist/cli/commands/connect.js

@@ -0,0 +1,171 @@
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+const STANDARD_MCP_ENTRY = {
+    command: 'npx',
+    args: ['vibe-orchestrator', 'serve'],
+    env: {},
+};
+const VSCODE_MCP_ENTRY = {
+    type: 'stdio',
+    command: 'npx',
+    args: ['vibe-orchestrator', 'serve'],
+};
+function hasBinary(name) {
+    try {
+        const cmd = process.platform === 'win32' ? `where ${name}` : `which ${name}`;
+        execSync(cmd, { stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function hasDir(dir) {
+    return fs.existsSync(dir);
+}
+function readJsonSafe(filePath) {
+    try {
+        const raw = fs.readFileSync(filePath, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+function writeJson(filePath, data) {
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8');
+}
+function isAlreadyConfigured(existing, serverKey) {
+    const mcpServers = existing['mcpServers'];
+    const servers = existing['servers'];
+    return !!(mcpServers?.[serverKey] || servers?.[serverKey]);
+}
+function addStandardEntry(existing, serverKey) {
+    const mcpServers = existing['mcpServers'] ?? {};
+    return {
+        ...existing,
+        mcpServers: {
+            ...mcpServers,
+            [serverKey]: STANDARD_MCP_ENTRY,
+        },
+    };
+}
+function addVSCodeEntry(existing, serverKey) {
+    const servers = existing['servers'] ?? {};
+    return {
+        ...existing,
+        servers: {
+            ...servers,
+            [serverKey]: VSCODE_MCP_ENTRY,
+        },
+    };
+}
+async function configureClaudeCode(cwd) {
+    const tool = 'Claude Code';
+    const claudeDir = path.join(cwd, '.claude');
+    const detected = hasDir(claudeDir) || hasBinary('claude');
+    if (!detected) {
+        return { tool, configPath: '', status: 'skipped' };
+    }
+    const configPath = path.join(claudeDir, 'settings.json');
+    const existing = readJsonSafe(configPath);
+    if (isAlreadyConfigured(existing, 'vibe-orchestrator')) {
+        return { tool, configPath, status: 'already' };
+    }
+    writeJson(configPath, addStandardEntry(existing, 'vibe-orchestrator'));
+    return { tool, configPath, status: 'added' };
+}
+async function configureCursor(cwd) {
+    const tool = 'Cursor';
+    const cursorDir = path.join(cwd, '.cursor');
+    const detected = hasDir(cursorDir) || hasBinary('cursor');
+    if (!detected) {
+        return { tool, configPath: '', status: 'skipped' };
+    }
+    const configPath = path.join(cursorDir, 'mcp.json');
+    const existing = readJsonSafe(configPath);
+    if (isAlreadyConfigured(existing, 'vibe-orchestrator')) {
+        return { tool, configPath, status: 'already' };
+    }
+    writeJson(configPath, addStandardEntry(existing, 'vibe-orchestrator'));
+    return { tool, configPath, status: 'added' };
+}
+async function configureVSCode(cwd) {
+    const tool = 'VS Code';
+    const vscodeDir = path.join(cwd, '.vscode');
+    const detected = hasDir(vscodeDir) || hasBinary('code');
+    if (!detected) {
+        return { tool, configPath: '', status: 'skipped' };
+    }
+    const configPath = path.join(vscodeDir, 'mcp.json');
+    const existing = readJsonSafe(configPath);
+    if (isAlreadyConfigured(existing, 'vibe-orchestrator')) {
+        return { tool, configPath, status: 'already' };
+    }
+    writeJson(configPath, addVSCodeEntry(existing, 'vibe-orchestrator'));
+    return { tool, configPath, status: 'added' };
+}
+// Windsurf도 글로벌 설정(~/.codeium/)이므로 자동 설정 제외
+async function configureWindsurf() {
+    return { tool: 'Windsurf', configPath: '', status: 'skipped' };
+}
+// Claude Desktop과 Gemini CLI는 글로벌 설정 파일을 수정하므로
+// vibe init 시 자동 설정하지 않습니다.
+// 원하면 vibe connect --global 로 별도 실행하세요. (미구현)
+async function configureClaudeDesktop() {
+    return { tool: 'Claude Desktop', configPath: '', status: 'skipped' };
+}
+async function configureGeminiCLI() {
+    return { tool: 'Gemini CLI', configPath: '', status: 'skipped' };
+}
+export async function connectCommand(cwd) {
+    console.log(chalk.cyan('\n🔌 AI 도구 자동 설정 중...\n'));
+    const results = await Promise.all([
+        configureClaudeCode(cwd),
+        configureCursor(cwd),
+        configureVSCode(cwd),
+        configureWindsurf(),
+        configureClaudeDesktop(),
+        configureGeminiCLI(),
+    ]);
+    let addedCount = 0;
+    let alreadyCount = 0;
+    let skippedCount = 0;
+    for (const result of results) {
+        if (result.status === 'added') {
+            console.log(chalk.green(`  ✅ ${result.tool} — 설정 완료`));
+            console.log(chalk.gray(`     ${result.configPath}`));
+            addedCount++;
+        }
+        else if (result.status === 'already') {
+            console.log(chalk.yellow(`  ☑️  ${result.tool} — 이미 설정됨`));
+            alreadyCount++;
+        }
+        else {
+            console.log(chalk.gray(`  ⬜ ${result.tool} — 미감지`));
+            skippedCount++;
+        }
+    }
+    console.log('');
+    if (addedCount === 0 && alreadyCount === 0) {
+        console.log(chalk.yellow('감지된 AI 도구가 없습니다.\nCursor, VS Code, Claude Code 중 하나를 설치하거나\n해당 도구의 프로젝트 디렉터리(.cursor, .vscode, .claude)를 먼저 만들어주세요.'));
+    }
+    else {
+        const parts = [];
+        if (addedCount > 0)
+            parts.push(`${addedCount}개 도구 설정 완료`);
+        if (alreadyCount > 0)
+            parts.push(`${alreadyCount}개 이미 설정됨`);
+        if (skippedCount > 0)
+            parts.push(`${skippedCount}개 미감지`);
+        console.log(chalk.green(`✨ ${parts.join(', ')}`));
+        console.log(chalk.gray('  AI 도구를 재시작하면 vibe-orchestrator MCP가 활성화됩니다.\n'));
+    }
+}
+//# sourceMappingURL=connect.js.map

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

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

package/dist/cli/commands/init.js

@@ -0,0 +1,149 @@
+import inquirer from 'inquirer';
+import ora from 'ora';
+import chalk from 'chalk';
+import { writeFile } from 'fs/promises';
+import path from 'path';
+import { listOpenIssues } from '../../github/issues.js';
+import { getFileContent, getRootStructure } from '../../github/files.js';
+import { generateCharter } from '../../charter/generator.js';
+import { ensureVibeDir, writeState, writeConfig, writeCharter } from '../../state/writer.js';
+import { detectGitHubToken, parseGitHubUrl, getDefaultBranch } from '../../github/auth.js';
+import { getAIProvider } from '../../ai/client.js';
+import { connectCommand } from './connect.js';
+export async function initCommand() {
+    const startTime = Date.now();
+    const cwd = process.cwd();
+    console.log(chalk.bold('\n🚀 Vibe Orchestrator 초기화\n'));
+    // AI 제공자 확인
+    const aiProvider = getAIProvider();
+    if (!aiProvider) {
+        console.log(chalk.yellow('⚠️  AI API 키가 없습니다. CHARTER 자동 생성을 건너뜁니다.\n' +
+            '   (ANTHROPIC_API_KEY 또는 OPENAI_API_KEY를 설정하면 CHARTER가 자동 생성됩니다)\n'));
+    }
+    // GitHub 토큰 자동 감지
+    const detectedToken = await detectGitHubToken();
+    if (detectedToken) {
+        console.log(chalk.green('✓ GitHub 인증 감지됨\n'));
+    }
+    else {
+        console.log(chalk.yellow('⚠️  GitHub 인증이 필요합니다.\n' +
+            '   아래 중 하나를 실행하세요:\n' +
+            '   • vibe auth login  — 브라우저로 GitHub 로그인 (권장)\n' +
+            '   • gh auth login    — GitHub CLI 로그인\n'));
+        process.exit(1);
+    }
+    const answers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'projectName',
+            message: '이 프로젝트 이름이 뭔가요?',
+            validate: (v) => v.trim() ? true : '프로젝트 이름을 입력해주세요.',
+        },
+        {
+            type: 'input',
+            name: 'repoUrl',
+            message: 'GitHub 레포 주소를 입력하세요 (예: https://github.com/owner/repo 또는 owner/repo):',
+            validate: (v) => parseGitHubUrl(v) ? true : '올바른 GitHub 레포 주소를 입력해주세요.',
+        },
+        {
+            type: 'input',
+            name: 'protectedPaths',
+            message: '건드리면 안 되는 중요한 폴더가 있나요? (쉼표로 구분, 없으면 엔터)',
+            default: '',
+        },
+    ]);
+    // URL 파싱
+    const parsed = parseGitHubUrl(answers.repoUrl);
+    if (!parsed) {
+        console.error(chalk.red('❌ GitHub 레포 주소 파싱 실패'));
+        process.exit(1);
+    }
+    const { owner, repo } = parsed;
+    const token = detectedToken;
+    // 기본 브랜치 자동 감지
+    const branchSpinner = ora(`${owner}/${repo} 정보 확인 중...`).start();
+    const defaultBranch = await getDefaultBranch(owner, repo, token);
+    branchSpinner.succeed(`기본 브랜치: ${chalk.cyan(defaultBranch)}`);
+    const protectedPaths = answers.protectedPaths
+        .split(',')
+        .map((p) => p.trim())
+        .filter(Boolean);
+    const config = {
+        owner,
+        repo,
+        defaultBranch,
+        protectedPaths,
+    };
+    // 1. 디렉토리 생성 + config 저장
+    await ensureVibeDir(cwd);
+    await writeConfig(cwd, config);
+    // 2. 이슈 목록 가져오기
+    const issueSpinner = ora('GitHub 이슈 목록 가져오는 중...').start();
+    const openIssues = await listOpenIssues(owner, repo);
+    issueSpinner.succeed(`이슈 ${openIssues.length}개 로드됨`);
+    // 3. state.json 초기화
+    const initialState = {
+        project: answers.projectName,
+        lastUpdated: new Date().toISOString(),
+        collaborators: {},
+        activeWork: null,
+        issues: openIssues,
+        workLog: [],
+    };
+    await writeState(cwd, initialState);
+    // 4. 레포 분석 + CHARTER 생성
+    const analysisSpinner = ora('레포 분석 중...').start();
+    const [readme, packageJson, rootStructure] = await Promise.all([
+        getFileContent(owner, repo, 'README.md'),
+        getFileContent(owner, repo, 'package.json'),
+        getRootStructure(owner, repo),
+    ]);
+    if (aiProvider) {
+        analysisSpinner.text = 'CHARTER 초안 생성 중 (약 20초)...';
+        try {
+            const charter = await generateCharter({
+                projectName: answers.projectName,
+                owner,
+                repo,
+                readme,
+                packageJson,
+                rootStructure,
+                openIssues,
+            });
+            await writeCharter(cwd, charter);
+            analysisSpinner.succeed('CHARTER.md 생성됨');
+        }
+        catch {
+            analysisSpinner.warn('CHARTER 생성 실패 — 나중에 수동으로 작성해주세요');
+            await writeCharter(cwd, `# CHARTER — ${answers.projectName}\n\n<!-- TODO: 채워주세요 -->\n`);
+        }
+    }
+    else {
+        analysisSpinner.stop();
+        await writeCharter(cwd, `# CHARTER — ${answers.projectName}\n\n<!-- TODO: 채워주세요 -->\n`);
+    }
+    // 5. mcp.json 생성 (운영자가 서버에서 API 키 관리 — 사용자 측 env 불필요)
+    const mcpConfig = {
+        mcpServers: {
+            'vibe-orchestrator': {
+                command: 'npx',
+                args: ['vibe-orchestrator', 'serve'],
+                env: {},
+            },
+        },
+    };
+    await writeFile(path.join(cwd, '.vibe', 'mcp.json'), JSON.stringify(mcpConfig, null, 2), 'utf-8');
+    const elapsed = Math.round((Date.now() - startTime) / 1000);
+    console.log(chalk.green(`
+✅ Vibe Orchestrator 초기화 완료! (소요: ${elapsed}초)
+
+생성된 파일:
+  CHARTER.md         — 레포 컨벤션 (직접 수정해서 정확하게 만드세요)
+  .vibe/state.json   — 협업 로그
+  .vibe/config.json  — 설정 (owner: ${owner}, repo: ${repo}, branch: ${defaultBranch})
+  .vibe/mcp.json     — 에이전트 연결 설정
+`));
+    // AI 도구 자동 설정
+    await connectCommand(cwd);
+}
+//# sourceMappingURL=init.js.map

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

@@ -0,0 +1,2 @@
+import 'dotenv/config';
+export declare function serveCommand(): Promise<void>;

package/dist/cli/commands/serve.js

@@ -0,0 +1,26 @@
+import 'dotenv/config';
+import { startMCPServer } from '../../mcp/server.js';
+import { detectGitHubToken } from '../../github/auth.js';
+import { getAIProvider } from '../../ai/client.js';
+export async function serveCommand() {
+    // AI 제공자 확인 (경고만, 종료 안 함)
+    const aiProvider = getAIProvider();
+    if (!aiProvider) {
+        process.stderr.write('[Vibe Orchestrator] ⚠️  AI API 키 없음 — AI 기능(CHARTER 생성, QA, PR 설명)이 비활성화됩니다.\n' +
+            '[Vibe Orchestrator]    ANTHROPIC_API_KEY 또는 OPENAI_API_KEY를 설정하면 활성화됩니다.\n');
+    }
+    else {
+        process.stderr.write(`[Vibe Orchestrator] ✓ AI 제공자: ${aiProvider}\n`);
+    }
+    // GitHub 토큰 확인 (gh CLI 포함)
+    const githubToken = await detectGitHubToken();
+    if (!githubToken) {
+        process.stderr.write('[Vibe Orchestrator] ⚠️  GitHub 토큰 없음 — GitHub 연동 기능이 제한됩니다.\n' +
+            '[Vibe Orchestrator]    gh auth login 또는 GITHUB_TOKEN 환경변수를 설정해주세요.\n');
+    }
+    else {
+        process.stderr.write('[Vibe Orchestrator] ✓ GitHub 인증 확인됨\n');
+    }
+    await startMCPServer();
+}
+//# sourceMappingURL=serve.js.map

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

@@ -0,0 +1,4 @@
+export declare function startCommand(options: {
+    user?: string;
+    githubId?: string;
+}): Promise<void>;

package/dist/cli/commands/start.js

@@ -0,0 +1,307 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { callAI, getAIProvider } from '../../ai/client.js';
+import { readState, readCharter, readIntentLog, readConfig } from '../../state/reader.js';
+import { writeState, registerCollaborator, setActiveWork, updateIssueStage, appendWorkLog, } from '../../state/writer.js';
+import { branchExists, createBranch } from '../../github/branches.js';
+import { createIssue } from '../../github/issues.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;
+}
+function slugify(title) {
+    return (title
+        .toLowerCase()
+        .replace(/[가-힣]/g, '')
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '')
+        .substring(0, 30) || 'task');
+}
+function formatDateTime(isoString) {
+    const d = new Date(isoString);
+    return d.toLocaleString('ko-KR');
+}
+export async function startCommand(options) {
+    const cwd = process.cwd();
+    const state = await readState(cwd);
+    const config = await readConfig(cwd);
+    // 1. 사용자 확인/등록
+    let name = options.user;
+    let githubId = options.githubId;
+    if (!name || !githubId) {
+        const userAnswers = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'name',
+                message: '이름이 뭔가요?',
+                when: !name,
+                default: name,
+            },
+            {
+                type: 'input',
+                name: 'githubId',
+                message: 'GitHub 아이디가 뭔가요?',
+                when: !githubId,
+                default: githubId,
+            },
+        ]);
+        name = (name ?? userAnswers.name);
+        githubId = (githubId ?? userAnswers.githubId);
+    }
+    // Collaborator 등록
+    await registerCollaborator(cwd, githubId, {
+        name,
+        githubId,
+        lastActive: new Date().toISOString(),
+    });
+    // 2. 재개 감지
+    const freshState = await readState(cwd);
+    if (freshState.activeWork?.paused && freshState.activeWork.actor === githubId) {
+        const aw = freshState.activeWork;
+        const pausedIssue = freshState.issues.find((i) => i.number === aw.issueNumber);
+        console.log(chalk.yellow(`
+👋 다시 오셨군요, ${name}님!
+
+아까 하던 작업이 있습니다:
+  · "${pausedIssue?.title ?? `이슈 #${aw.issueNumber}`}"
+  · 멈춘 시각: ${aw.pausedAt ? formatDateTime(aw.pausedAt) : '알 수 없음'}
+  · 현재 단계: ${stageToKorean(aw.stage)}
+`));
+        const resumeAnswer = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'choice',
+                message: '어떻게 하시겠어요?',
+                choices: ['이어서 진행', '다른 작업 선택'],
+            },
+        ]);
+        if (resumeAnswer.choice === '이어서 진행') {
+            // activeWork 재개
+            await setActiveWork(cwd, {
+                ...aw,
+                paused: false,
+                pausedAt: null,
+            });
+            // 컨텍스트 블록 출력
+            await printContextBlock({
+                cwd,
+                name,
+                githubId,
+                issueNumber: aw.issueNumber,
+                issueTitle: pausedIssue?.title ?? `이슈 #${aw.issueNumber}`,
+                branchName: pausedIssue?.branch ?? '',
+                userRequest: '이전 작업 재개',
+            });
+            return;
+        }
+    }
+    // 3. 새 작업 시작
+    const requestAnswer = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'request',
+            message: '어떤 작업을 하고 싶으신가요?',
+        },
+    ]);
+    const userRequest = requestAnswer.request;
+    // Claude API로 이슈 매칭
+    const freshState2 = await readState(cwd);
+    const openIssues = freshState2.issues.filter((i) => i.status === 'open' || i.status === 'in_progress');
+    let matchedIssueNumber = null;
+    let matchedIssueTitle = '';
+    let isNewIssue = false;
+    let suggestedTitle = userRequest;
+    if (openIssues.length > 0 && getAIProvider()) {
+        try {
+            const issueList = openIssues.map((i) => `#${i.number}: ${i.title}`).join('\n');
+            const raw = await callAI({
+                system: '사용자 요청과 이슈 목록을 비교해서 가장 관련 있는 이슈를 찾아라. 반드시 순수 JSON만 반환 (마크다운 코드블록 없이): { "matched": true|false, "issueNumber": number|null, "confidence": 0~1, "reason": string }',
+                user: `요청: ${userRequest}\n\n이슈 목록:\n${issueList}`,
+                tier: 'fast',
+            });
+            const clean = raw.replace(/```json\n?/g, '').replace(/```\n?/g, '').trim();
+            const parsed = JSON.parse(clean);
+            if (parsed.matched && parsed.confidence >= 0.7 && parsed.issueNumber) {
+                matchedIssueNumber = parsed.issueNumber;
+                matchedIssueTitle =
+                    openIssues.find((i) => i.number === parsed.issueNumber)?.title ?? '';
+            }
+            else {
+                isNewIssue = true;
+                suggestedTitle = userRequest.substring(0, 50);
+            }
+        }
+        catch {
+            isNewIssue = true;
+            suggestedTitle = userRequest.substring(0, 50);
+        }
+    }
+    else {
+        isNewIssue = true;
+        suggestedTitle = userRequest.substring(0, 50);
+    }
+    let finalIssueNumber;
+    let finalIssueTitle;
+    if (matchedIssueNumber && !isNewIssue) {
+        // 체크포인트 A — 기존 이슈 매칭
+        console.log(chalk.cyan(`
+관련된 작업 항목이 있습니다:
+
+  #${matchedIssueNumber} "${matchedIssueTitle}"
+
+이 작업에 이어서 작업할까요, 아니면 새로 시작할까요?`));
+        const workChoice = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'choice',
+                message: '선택하세요:',
+                choices: ['이어서 작업', '새로 시작'],
+            },
+        ]);
+        if (workChoice.choice === '이어서 작업') {
+            finalIssueNumber = matchedIssueNumber;
+            finalIssueTitle = matchedIssueTitle;
+        }
+        else {
+            isNewIssue = true;
+            finalIssueNumber = 0;
+            finalIssueTitle = suggestedTitle;
+        }
+    }
+    else {
+        finalIssueNumber = 0;
+        finalIssueTitle = suggestedTitle;
+    }
+    if (isNewIssue || finalIssueNumber === 0) {
+        console.log(chalk.cyan(`
+관련된 기존 작업이 없습니다. 새 작업 항목을 만들까요?
+
+  제목: "${suggestedTitle}"`));
+        const createAnswer = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'create',
+                message: '새 작업 항목을 만들까요?',
+                default: true,
+            },
+        ]);
+        if (!createAnswer.create) {
+            console.log(chalk.yellow('작업을 취소했습니다.'));
+            return;
+        }
+        if (config) {
+            const newIssueNumber = await createIssue(config.owner, config.repo, suggestedTitle, `Vibe Orchestrator로 생성된 작업\n\n요청: ${userRequest}`);
+            finalIssueNumber = newIssueNumber;
+            finalIssueTitle = suggestedTitle;
+            // state에 추가
+            const state3 = await readState(cwd);
+            state3.issues.push({
+                number: finalIssueNumber,
+                title: finalIssueTitle,
+                status: 'open',
+                branch: null,
+                assignee: null,
+                stage: 'not_started',
+                prNumber: null,
+                intentLogPath: null,
+            });
+            await writeState(cwd, state3);
+        }
+        else {
+            console.log(chalk.red('config.json이 없어 GitHub 이슈를 생성할 수 없습니다.'));
+            return;
+        }
+    }
+    // 브랜치 생성
+    const branchName = `vibe/${githubId}/${finalIssueNumber}/${slugify(finalIssueTitle)}`;
+    if (config) {
+        const exists = await branchExists(config.owner, config.repo, branchName);
+        if (!exists) {
+            await createBranch(config.owner, config.repo, branchName, config.defaultBranch);
+        }
+    }
+    // state 업데이트
+    await setActiveWork(cwd, {
+        issueNumber: finalIssueNumber,
+        actor: githubId,
+        stage: 'work_started',
+        startedAt: new Date().toISOString(),
+        paused: false,
+        pausedAt: null,
+        retryCount: 0,
+    });
+    await updateIssueStage(cwd, finalIssueNumber, {
+        status: 'in_progress',
+        branch: branchName,
+        assignee: githubId,
+        stage: 'work_started',
+    });
+    await appendWorkLog(cwd, {
+        actor: { name, githubId, agent: 'cli' },
+        stage: 'work_started',
+        issueNumber: finalIssueNumber,
+        action: 'start_work',
+        message: `작업 시작: #${finalIssueNumber} "${finalIssueTitle}"`,
+    });
+    // 컨텍스트 블록 출력
+    await printContextBlock({
+        cwd,
+        name,
+        githubId,
+        issueNumber: finalIssueNumber,
+        issueTitle: finalIssueTitle,
+        branchName,
+        userRequest,
+    });
+}
+async function printContextBlock(params) {
+    const { cwd, name, githubId, issueNumber, issueTitle, branchName, userRequest } = params;
+    const charter = await readCharter(cwd);
+    const state = await readState(cwd);
+    const intentLog = await readIntentLog(cwd, issueNumber);
+    const inProgress = state.issues.filter((i) => i.status === 'in_progress' || i.status === 'pr_created');
+    const stateSummary = inProgress.length > 0
+        ? inProgress.map((i) => `  #${i.number} ${i.title} (${i.assignee ?? '미배정'})`).join('\n')
+        : '  진행 중인 작업 없음';
+    const intentContent = intentLog
+        ? `결정 사항: ${intentLog.decided.join(', ')}\n거절된 방안: ${intentLog.rejected.join(', ')}`
+        : '없음 (새 작업)';
+    console.log(chalk.green(`
+═══════════════════════════════════════════════════════
+✅ 준비 완료! 아래 내용을 AI에게 복사해서 넣어주세요:
+(MCP 연결 시에는 자동으로 주입됩니다)
+═══════════════════════════════════════════════════════
+
+[Vibe Orchestrator 컨텍스트]
+작업자: ${name} (${githubId})
+작업: 이슈 #${issueNumber} — ${issueTitle}
+브랜치: ${branchName}
+
+=== CHARTER ===
+${charter || '(CHARTER 없음)'}
+
+=== 팀 현황 ===
+${stateSummary}
+
+=== 의도 로그 ===
+${intentContent}
+
+요청사항: ${userRequest}
+
+───────────────────────────────────────────────────────
+MCP 연결 방법: claude --mcp-config .vibe/mcp.json
+═══════════════════════════════════════════════════════
+`));
+}
+//# sourceMappingURL=start.js.map

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

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