@pollit/twin-dev-bot 0.0.1

package/dist/slack/question-blocks.js

@@ -0,0 +1,235 @@
+import { t } from "../i18n/index.js";
+const SLACK_BLOCK_LIMIT = 50;
+const SLACK_BUTTON_TEXT_LIMIT = 75;
+/** 버튼 텍스트가 Slack 제한(75자)을 초과하면 말줄임표(…)를 붙여 잘린 것을 표시 */
+function truncateButtonText(text) {
+    if (text.length <= SLACK_BUTTON_TEXT_LIMIT)
+        return text;
+    return text.slice(0, SLACK_BUTTON_TEXT_LIMIT - 1) + "…";
+}
+/**
+ * AskUserQuestion을 Slack Block으로 변환
+ * 단일 질문을 렌더링하고, 버튼 클릭 시 바로 Claude에 전달
+ *
+ * 주의: 버튼 value에는 짧은 필드만 포함.
+ * questionText, header, optionLabels 등은 action-payload-store에 별도 저장되어
+ * 핸들러에서 messageId로 조회함 (Slack action.value ~2,000바이트 제한 대응).
+ */
+export function buildQuestionBlocks(options) {
+    const { question, projectName, messageId, selectedAnswer, isSubmitted = false, selectedOptionIndexes = [], } = options;
+    const blocks = [];
+    // 헤더
+    blocks.push({
+        type: "header",
+        text: {
+            type: "plain_text",
+            text: isSubmitted ? t("question.headerCompleted") : t("question.header"),
+            emoji: true,
+        },
+    });
+    // 질문 제목
+    if (question.header) {
+        blocks.push({
+            type: "section",
+            text: { type: "mrkdwn", text: `*${question.header}*` },
+        });
+    }
+    // 질문 내용
+    blocks.push({
+        type: "section",
+        text: { type: "mrkdwn", text: question.question },
+    });
+    blocks.push({ type: "divider" });
+    if (isSubmitted && selectedAnswer) {
+        // 완료 상태 - 체크 이모지와 선택된 답변 표시
+        blocks.push({
+            type: "section",
+            text: { type: "mrkdwn", text: `✅ *${selectedAnswer}*` },
+        });
+    }
+    else if (question.multiSelect) {
+        // 복수 선택 모드 - 토글 버튼 + 선택 완료 버튼
+        const selectedSet = new Set(selectedOptionIndexes);
+        if (question.options && question.options.length > 0) {
+            // Slack 블록 50개 제한 대응: 옵션 렌더링 전략 결정
+            const trailingBlocks = 3; // submit + textInput + hint
+            const availableForOptions = SLACK_BLOCK_LIMIT - blocks.length - trailingBlocks;
+            const descriptionCount = question.options.filter(o => o.description).length;
+            const totalWithDesc = question.options.length + descriptionCount;
+            let skipDescriptions = false;
+            let optionsToRender = question.options;
+            if (totalWithDesc > availableForOptions) {
+                skipDescriptions = true;
+                if (question.options.length > availableForOptions) {
+                    // 잘림 안내 context 블록 1개를 위해 -1
+                    const maxOptions = Math.max(1, availableForOptions - 1);
+                    optionsToRender = question.options.slice(0, maxOptions);
+                }
+            }
+            const isTruncated = optionsToRender.length < question.options.length;
+            optionsToRender.forEach((opt, i) => {
+                const isSelected = selectedSet.has(i);
+                const buttonText = isSelected ? `✅ ${opt.label}` : opt.label;
+                const toggleValue = {
+                    questionIndex: 0,
+                    optionIndex: i,
+                    label: opt.label,
+                    projectName,
+                    messageId,
+                };
+                const button = {
+                    type: "button",
+                    text: { type: "plain_text", text: truncateButtonText(buttonText), emoji: true },
+                    value: JSON.stringify(toggleValue),
+                    action_id: `toggle_option_0_${i}`,
+                    style: isSelected ? "primary" : undefined,
+                };
+                blocks.push({
+                    type: "actions",
+                    elements: [button],
+                });
+                // 설명이 있으면 버튼 아래에 표시 (블록 제한 시 생략)
+                if (!skipDescriptions && opt.description) {
+                    blocks.push({
+                        type: "context",
+                        elements: [{ type: "plain_text", text: opt.description, emoji: false }],
+                    });
+                }
+            });
+            if (isTruncated) {
+                blocks.push({
+                    type: "context",
+                    elements: [{ type: "mrkdwn", text: t("question.truncatedOptions", { shown: String(optionsToRender.length), total: String(question.options.length) }) }],
+                });
+            }
+        }
+        // 선택 완료 버튼
+        const submitValue = {
+            questionIndex: 0,
+            projectName,
+            messageId,
+        };
+        blocks.push({
+            type: "actions",
+            block_id: "submit_multi_select_0",
+            elements: [
+                {
+                    type: "button",
+                    text: { type: "plain_text", text: t("question.submitSelection"), emoji: true },
+                    value: JSON.stringify(submitValue),
+                    action_id: "submit_multi_select_0",
+                    style: "primary",
+                },
+            ],
+        });
+        // 직접 입력 버튼 (멀티 선택에서도 직접 입력 가능)
+        const multiSelectTextInputValue = {
+            questionIndex: 0,
+            type: "text_input",
+            projectName,
+            messageId,
+        };
+        blocks.push({
+            type: "actions",
+            block_id: "text_input_0",
+            elements: [
+                {
+                    type: "button",
+                    text: { type: "plain_text", text: t("question.textInput"), emoji: true },
+                    value: JSON.stringify(multiSelectTextInputValue),
+                    action_id: "text_input_0",
+                },
+            ],
+        });
+        // 현재 선택된 항목 안내
+        if (selectedOptionIndexes.length > 0) {
+            const selectedLabels = selectedOptionIndexes
+                .map(i => question.options[i]?.label)
+                .filter(Boolean)
+                .join(", ");
+            blocks.push({
+                type: "context",
+                elements: [{ type: "mrkdwn", text: t("question.currentSelection", { labels: selectedLabels }) }],
+            });
+        }
+        else {
+            blocks.push({
+                type: "context",
+                elements: [{ type: "mrkdwn", text: t("question.selectHint") }],
+            });
+        }
+    }
+    else {
+        // 단일 선택 모드 - 기존 로직
+        if (question.options && question.options.length > 0) {
+            // Slack 블록 50개 제한 대응: 옵션 렌더링 전략 결정
+            const trailingBlocks = 1; // textInput
+            const availableForOptions = SLACK_BLOCK_LIMIT - blocks.length - trailingBlocks;
+            const descriptionCount = question.options.filter(o => o.description).length;
+            const totalWithDesc = question.options.length + descriptionCount;
+            let skipDescriptions = false;
+            let optionsToRender = question.options;
+            if (totalWithDesc > availableForOptions) {
+                skipDescriptions = true;
+                if (question.options.length > availableForOptions) {
+                    const maxOptions = Math.max(1, availableForOptions - 1);
+                    optionsToRender = question.options.slice(0, maxOptions);
+                }
+            }
+            const isTruncated = optionsToRender.length < question.options.length;
+            optionsToRender.forEach((opt, i) => {
+                const buttonValue = {
+                    questionIndex: 0,
+                    optionIndex: i,
+                    label: opt.label,
+                    isMultiSelect: false,
+                    projectName,
+                    messageId,
+                };
+                const button = {
+                    type: "button",
+                    text: { type: "plain_text", text: truncateButtonText(opt.label), emoji: true },
+                    value: JSON.stringify(buttonValue),
+                    action_id: `select_option_0_${i}`,
+                };
+                blocks.push({
+                    type: "actions",
+                    elements: [button],
+                });
+                // 설명이 있으면 버튼 아래에 표시 (블록 제한 시 생략)
+                if (!skipDescriptions && opt.description) {
+                    blocks.push({
+                        type: "context",
+                        elements: [{ type: "plain_text", text: opt.description, emoji: false }],
+                    });
+                }
+            });
+            if (isTruncated) {
+                blocks.push({
+                    type: "context",
+                    elements: [{ type: "mrkdwn", text: t("question.truncatedOptions", { shown: String(optionsToRender.length), total: String(question.options.length) }) }],
+                });
+            }
+        }
+        // 직접 입력 버튼
+        const textInputValue = {
+            questionIndex: 0,
+            type: "text_input",
+            projectName,
+            messageId,
+        };
+        blocks.push({
+            type: "actions",
+            block_id: "text_input_0",
+            elements: [
+                {
+                    type: "button",
+                    text: { type: "plain_text", text: t("question.textInput"), emoji: true },
+                    value: JSON.stringify(textInputValue),
+                    action_id: "text_input_0",
+                },
+            ],
+        });
+    }
+    return blocks;
+}

package/dist/stores/action-payload-store.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Slack action.value (~2,000 bytes) 및 private_metadata (~3,000 bytes) 크기 제한 대응.
+ * 큰 페이로드를 서버 사이드에 저장하고 짧은 키만 버튼 값에 포함.
+ * TTL 기반 자동 정리로 메모리 누수 방지.
+ */
+/**
+ * 페이로드 저장
+ */
+export declare function setPayload(key: string, data: unknown, ttlMs?: number): void;
+/**
+ * 페이로드 조회 (기본: 조회 후 삭제하지 않음)
+ * @param remove true이면 조회 후 삭제 (일회성 데이터용)
+ */
+export declare function getPayload<T>(key: string, remove?: boolean): T | null;
+/**
+ * 페이로드 삭제
+ */
+export declare function removePayload(key: string): void;
+/**
+ * 테스트용: 스토어 전체 초기화
+ */
+export declare function clearAllPayloads(): void;

package/dist/stores/action-payload-store.js

@@ -0,0 +1,54 @@
+/**
+ * Slack action.value (~2,000 bytes) 및 private_metadata (~3,000 bytes) 크기 제한 대응.
+ * 큰 페이로드를 서버 사이드에 저장하고 짧은 키만 버튼 값에 포함.
+ * TTL 기반 자동 정리로 메모리 누수 방지.
+ */
+const store = new Map();
+const DEFAULT_TTL_MS = 2 * 60 * 60 * 1000; // 2시간
+function cleanup() {
+    const now = Date.now();
+    for (const [key, entry] of store) {
+        if (now > entry.expiresAt)
+            store.delete(key);
+    }
+}
+/**
+ * 페이로드 저장
+ */
+export function setPayload(key, data, ttlMs = DEFAULT_TTL_MS) {
+    cleanup();
+    store.set(key, { data, expiresAt: Date.now() + ttlMs });
+}
+/**
+ * 페이로드 조회 (기본: 조회 후 삭제하지 않음)
+ * @param remove true이면 조회 후 삭제 (일회성 데이터용)
+ */
+export function getPayload(key, remove = false) {
+    const entry = store.get(key);
+    if (!entry)
+        return null;
+    if (Date.now() > entry.expiresAt) {
+        store.delete(key);
+        return null;
+    }
+    if (remove) {
+        store.delete(key);
+    }
+    else {
+        // TTL 갱신: 접근 시 만료 시간 리셋 (사용자가 상호작용 중임을 표시)
+        entry.expiresAt = Date.now() + DEFAULT_TTL_MS;
+    }
+    return entry.data;
+}
+/**
+ * 페이로드 삭제
+ */
+export function removePayload(key) {
+    store.delete(key);
+}
+/**
+ * 테스트용: 스토어 전체 초기화
+ */
+export function clearAllPayloads() {
+    store.clear();
+}

package/dist/stores/channel-store.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Channel Store
+ *
+ * 슬랙 채널과 작업 디렉토리의 매핑을 관리합니다.
+ * /twindevbot init으로 설정된 채널별 작업 디렉토리를 영속적으로 저장합니다.
+ *
+ * 키: channelId (Slack 채널 ID)
+ * 값: { directory, projectName }
+ */
+export interface ChannelDir {
+    directory: string;
+    projectName: string;
+}
+export declare function setChannelDir(channelId: string, dir: ChannelDir): void;
+export declare function getChannelDir(channelId: string): ChannelDir | undefined;
+export declare function removeChannelDir(channelId: string): void;

package/dist/stores/channel-store.js

@@ -0,0 +1,91 @@
+/**
+ * Channel Store
+ *
+ * 슬랙 채널과 작업 디렉토리의 매핑을 관리합니다.
+ * /twindevbot init으로 설정된 채널별 작업 디렉토리를 영속적으로 저장합니다.
+ *
+ * 키: channelId (Slack 채널 ID)
+ * 값: { directory, projectName }
+ */
+import { existsSync, readFileSync, writeFileSync, renameSync } from "fs";
+import { createLogger } from "../core/logger.js";
+import { CHANNELS_FILE } from "../core/paths.js";
+const log = createLogger("channel-store");
+const channels = new Map();
+function loadFromFile() {
+    try {
+        if (!existsSync(CHANNELS_FILE)) {
+            log.info("No channels file found, starting fresh");
+            return;
+        }
+        const content = readFileSync(CHANNELS_FILE, "utf-8");
+        let data;
+        try {
+            data = JSON.parse(content);
+        }
+        catch (parseError) {
+            log.error("Channels file is corrupted, starting fresh", { parseError });
+            return;
+        }
+        if (!data.channels || !Array.isArray(data.channels)) {
+            log.error("Channels file has invalid structure, starting fresh");
+            return;
+        }
+        let loadedCount = 0;
+        for (const c of data.channels) {
+            try {
+                channels.set(c.channelId, {
+                    directory: c.directory,
+                    projectName: c.projectName,
+                });
+                loadedCount++;
+            }
+            catch (entryError) {
+                log.warn("Skipping invalid channel entry", { entry: c, error: entryError });
+            }
+        }
+        log.info("Channels loaded from file", { count: loadedCount, total: data.channels.length });
+    }
+    catch (error) {
+        log.error("Failed to load channels from file", { error });
+    }
+}
+function saveToFile() {
+    try {
+        const serialized = Array.from(channels.entries()).map(([channelId, c]) => ({
+            channelId,
+            directory: c.directory,
+            projectName: c.projectName,
+        }));
+        const data = {
+            version: 1,
+            channels: serialized,
+        };
+        const tmpFile = CHANNELS_FILE + ".tmp";
+        writeFileSync(tmpFile, JSON.stringify(data, null, 2));
+        renameSync(tmpFile, CHANNELS_FILE);
+        log.debug("Channels saved to file", { count: serialized.length });
+    }
+    catch (error) {
+        log.error("Failed to save channels to file", { error });
+    }
+}
+// 모듈 로드 시 파일에서 복원
+loadFromFile();
+export function setChannelDir(channelId, dir) {
+    channels.set(channelId, dir);
+    log.info("Channel directory set", {
+        channelId,
+        projectName: dir.projectName,
+        directory: dir.directory,
+    });
+    saveToFile();
+}
+export function getChannelDir(channelId) {
+    return channels.get(channelId);
+}
+export function removeChannelDir(channelId) {
+    channels.delete(channelId);
+    log.debug("Channel directory removed", { channelId });
+    saveToFile();
+}

package/dist/stores/multi-select-state.d.ts

@@ -0,0 +1,58 @@
+/**
+ * 복수 선택 상태 관리
+ *
+ * multiSelect가 true인 질문에서 사용자가 선택한 옵션들을
+ * "선택 완료" 버튼을 누르기 전까지 임시 저장합니다.
+ *
+ * 키: `${projectName}:${messageId}`
+ * 값: { selected: 선택된 옵션 인덱스 Set, options: 전체 옵션 배열 }
+ */
+import type { QuestionOption } from "../types/conversation.js";
+interface MultiSelectState {
+    selected: Set<number>;
+    options: QuestionOption[];
+    questionText: string;
+    header?: string;
+    createdAt: number;
+}
+interface InitStateOptions {
+    projectName: string;
+    messageId: string;
+    options: QuestionOption[];
+    questionText: string;
+    header?: string;
+}
+/**
+ * 상태 초기화 (질문 생성 시 호출)
+ */
+export declare function initState(opts: InitStateOptions): void;
+/**
+ * 옵션 토글 (선택/해제)
+ * @returns 토글 후 선택 여부
+ */
+export declare function toggleOption(projectName: string, messageId: string, optionIndex: number): boolean;
+/**
+ * 선택된 옵션 인덱스 배열 조회
+ */
+export declare function getSelectedOptions(projectName: string, messageId: string): number[];
+/**
+ * 전체 상태 조회 (옵션 정보 포함)
+ */
+export declare function getState(projectName: string, messageId: string): MultiSelectState | null;
+/**
+ * 특정 옵션이 선택되었는지 확인
+ */
+export declare function isOptionSelected(projectName: string, messageId: string, optionIndex: number): boolean;
+/**
+ * 상태 삭제 (완료 후 정리용)
+ */
+export declare function clearState(projectName: string, messageId: string): void;
+/**
+ * 정리 타이머 중지 (주로 테스트용)
+ */
+export declare function stopCleanupTimer(): void;
+/**
+ * 테스트용: cleanup 수동 실행
+ */
+export declare function runCleanup(): number;
+export {};

package/dist/stores/multi-select-state.js

@@ -0,0 +1,151 @@
+/**
+ * 복수 선택 상태 관리
+ *
+ * multiSelect가 true인 질문에서 사용자가 선택한 옵션들을
+ * "선택 완료" 버튼을 누르기 전까지 임시 저장합니다.
+ *
+ * 키: `${projectName}:${messageId}`
+ * 값: { selected: 선택된 옵션 인덱스 Set, options: 전체 옵션 배열 }
+ */
+import { createLogger } from "../core/logger.js";
+const log = createLogger("multi-select-state");
+/** 선택 상태 저장소 */
+const stateMap = new Map();
+// 1시간이 지난 상태는 자동 삭제 (multi-select는 오래 걸리지 않음)
+const MAX_AGE_MS = 60 * 60 * 1000;
+let cleanupInterval = null;
+/**
+ * 키 생성 헬퍼
+ */
+function makeKey(projectName, messageId) {
+    return `${projectName}:${messageId}`;
+}
+/**
+ * 상태 초기화 (질문 생성 시 호출)
+ */
+export function initState(opts) {
+    const key = makeKey(opts.projectName, opts.messageId);
+    if (stateMap.has(key)) {
+        log.debug("State already exists, skipping init", { key });
+        return;
+    }
+    stateMap.set(key, {
+        selected: new Set(),
+        options: opts.options,
+        questionText: opts.questionText,
+        header: opts.header,
+        createdAt: Date.now(),
+    });
+    log.debug("State initialized", { key, optionCount: opts.options.length });
+    // 타이머가 없으면 시작
+    ensureCleanupTimer();
+}
+/**
+ * 옵션 토글 (선택/해제)
+ * @returns 토글 후 선택 여부
+ */
+export function toggleOption(projectName, messageId, optionIndex) {
+    const key = makeKey(projectName, messageId);
+    const state = stateMap.get(key);
+    if (!state) {
+        log.warn("State not found for toggle", { key });
+        return false;
+    }
+    if (state.selected.has(optionIndex)) {
+        state.selected.delete(optionIndex);
+        log.debug("Option deselected", { projectName, messageId, optionIndex });
+        return false;
+    }
+    else {
+        state.selected.add(optionIndex);
+        log.debug("Option selected", { projectName, messageId, optionIndex });
+        return true;
+    }
+}
+/**
+ * 선택된 옵션 인덱스 배열 조회
+ */
+export function getSelectedOptions(projectName, messageId) {
+    const key = makeKey(projectName, messageId);
+    const state = stateMap.get(key);
+    if (!state) {
+        return [];
+    }
+    return Array.from(state.selected).sort((a, b) => a - b);
+}
+/**
+ * 전체 상태 조회 (옵션 정보 포함)
+ */
+export function getState(projectName, messageId) {
+    const key = makeKey(projectName, messageId);
+    return stateMap.get(key) ?? null;
+}
+/**
+ * 특정 옵션이 선택되었는지 확인
+ */
+export function isOptionSelected(projectName, messageId, optionIndex) {
+    const key = makeKey(projectName, messageId);
+    const state = stateMap.get(key);
+    return state?.selected.has(optionIndex) ?? false;
+}
+/**
+ * 상태 삭제 (완료 후 정리용)
+ */
+export function clearState(projectName, messageId) {
+    const key = makeKey(projectName, messageId);
+    stateMap.delete(key);
+    log.debug("State cleared", { projectName, messageId });
+}
+/**
+ * 오래된 상태 정리
+ */
+function cleanup() {
+    const now = Date.now();
+    let cleanedCount = 0;
+    for (const [key, state] of stateMap.entries()) {
+        const ageMs = now - state.createdAt;
+        if (ageMs > MAX_AGE_MS) {
+            stateMap.delete(key);
+            cleanedCount++;
+            log.info("Multi-select state expired", {
+                key,
+                ageMinutes: Math.floor(ageMs / (60 * 1000)),
+            });
+        }
+    }
+    if (cleanedCount > 0) {
+        log.info("Multi-select cleanup completed", { cleanedCount, remaining: stateMap.size });
+    }
+    return cleanedCount;
+}
+/**
+ * 정리 타이머 시작
+ */
+function ensureCleanupTimer() {
+    if (cleanupInterval)
+        return;
+    // 즉시 한 번 실행
+    cleanup();
+    // 매 시간마다 실행
+    cleanupInterval = setInterval(() => {
+        cleanup();
+    }, 60 * 60 * 1000);
+    cleanupInterval.unref();
+    log.debug("Multi-select cleanup timer started (runs every hour)");
+}
+/**
+ * 정리 타이머 중지 (주로 테스트용)
+ */
+export function stopCleanupTimer() {
+    if (cleanupInterval) {
+        clearInterval(cleanupInterval);
+        cleanupInterval = null;
+        log.debug("Multi-select cleanup timer stopped");
+    }
+}
+/**
+ * 테스트용: cleanup 수동 실행
+ */
+export function runCleanup() {
+    return cleanup();
+}

package/dist/stores/pending-questions.d.ts

@@ -0,0 +1,53 @@
+/**
+ * 복수 질문 배치 관리
+ *
+ * Claude의 AskUserQuestion이 여러 질문을 동시에 보낼 때,
+ * Slack에서는 한 번에 하나씩 표시하고 모든 답변을 수집한 후
+ * 조합하여 Claude에 전달합니다.
+ *
+ * 키: threadTs (스레드당 하나의 배치)
+ */
+import type { Question } from "../types/conversation.js";
+export interface PendingQuestionBatch {
+    questions: Question[];
+    answers: string[];
+    currentIndex: number;
+    projectName: string;
+    channelId: string;
+    createdAt: number;
+}
+/**
+ * 배치 초기화 (questions.length > 1일 때 호출)
+ */
+export declare function initPendingBatch(threadTs: string, questions: Question[], projectName: string, channelId: string): void;
+/**
+ * 대기 중인 배치 존재 여부
+ */
+export declare function hasPendingBatch(threadTs: string): boolean;
+/**
+ * 답변 기록 후 다음 질문 반환.
+ * done=true이면 모든 질문에 답변 완료.
+ */
+export declare function recordAnswerAndAdvance(threadTs: string, answer: string): {
+    done: boolean;
+    nextQuestion?: Question;
+    batch: PendingQuestionBatch;
+} | null;
+/**
+ * 모든 답변을 조합하여 Claude resume용 문자열 생성.
+ * 형식: "[header]: answer" (줄바꿈 구분)
+ * header가 없으면 질문 텍스트 앞 50자 사용.
+ */
+export declare function buildCombinedAnswer(threadTs: string): string | null;
+/**
+ * 배치 정리
+ */
+export declare function clearPendingBatch(threadTs: string): void;
+/**
+ * 정리 타이머 중지 (주로 테스트용)
+ */
+export declare function stopCleanupTimer(): void;
+/**
+ * 테스트용: cleanup 수동 실행
+ */
+export declare function runCleanup(): number;