@pollit/twin-dev-bot 0.0.1

package/dist/types/claude-stream.d.ts

@@ -0,0 +1,116 @@
+export interface ClaudeInitEvent {
+    type: "system";
+    subtype: "init";
+    cwd: string;
+    session_id: string;
+    tools: string[];
+    mcp_servers: Array<{
+        name: string;
+        status: string;
+    }>;
+    model: string;
+    permissionMode: string;
+    slash_commands: string[];
+    apiKeySource: string;
+    claude_code_version: string;
+    output_style: string;
+    agents: string[];
+    skills: string[];
+    plugins: string[];
+    uuid: string;
+}
+export interface ClaudeAssistantMessage {
+    type: "assistant";
+    message: {
+        model: string;
+        id: string;
+        type: "message";
+        role: "assistant";
+        content: ClaudeContentBlock[];
+        stop_reason: string | null;
+        stop_sequence: string | null;
+        usage: ClaudeUsage;
+        context_management: unknown | null;
+    };
+    parent_tool_use_id: string | null;
+    session_id: string;
+    uuid: string;
+}
+/** assistant 메시지의 content block */
+export interface ClaudeContentBlock {
+    type: "text" | "tool_use";
+    text?: string;
+    id?: string;
+    name?: string;
+    input?: Record<string, unknown>;
+}
+/** tool result를 담는 user 메시지 (도구 실행 후 Claude에게 결과를 전달) */
+export interface ClaudeUserMessage {
+    type: "user";
+    message: {
+        role: "user";
+        content: Array<{
+            tool_use_id: string;
+            type: "tool_result";
+            content: string;
+        }>;
+    };
+    parent_tool_use_id: string | null;
+    session_id: string;
+    uuid: string;
+    tool_use_result: {
+        type: string;
+        file?: {
+            filePath: string;
+            content: string;
+            numLines: number;
+            startLine: number;
+            totalLines: number;
+        };
+    };
+}
+export interface ClaudeResultEvent {
+    type: "result";
+    subtype: "success" | "error_max_turns" | "error_during_execution" | "error_max_budget_usd";
+    is_error: boolean;
+    duration_ms: number;
+    duration_api_ms: number;
+    num_turns: number;
+    result: string;
+    session_id: string;
+    total_cost_usd: number;
+    usage: ClaudeUsage;
+    modelUsage: Record<string, ClaudeModelUsage>;
+    permission_denials: Array<{
+        tool_name: string;
+        tool_use_id: string;
+        tool_input: unknown;
+    }>;
+    uuid: string;
+}
+export interface ClaudeUsage {
+    input_tokens: number;
+    output_tokens: number;
+    cache_creation_input_tokens?: number;
+    cache_read_input_tokens?: number;
+    cache_creation?: {
+        ephemeral_5m_input_tokens: number;
+        ephemeral_1h_input_tokens: number;
+    };
+    server_tool_use?: {
+        web_search_requests: number;
+        web_fetch_requests: number;
+    };
+    service_tier?: string;
+}
+export interface ClaudeModelUsage {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadInputTokens: number;
+    cacheCreationInputTokens: number;
+    webSearchRequests: number;
+    costUSD: number;
+    contextWindow: number;
+    maxOutputTokens: number;
+}
+export type ClaudeStreamEvent = ClaudeInitEvent | ClaudeAssistantMessage | ClaudeUserMessage | ClaudeResultEvent;

package/dist/types/claude-stream.js

@@ -0,0 +1,3 @@
+// Claude CLI `--output-format stream-json --verbose` raw stdout 타입 정의
+// 실제 CLI 출력을 기반으로 정의 (공식 스펙 문서 없음, CLI v2.1.25 기준)
+export {};

package/dist/types/conversation.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 질문 관련 타입 정의
+ */
+/**
+ * 질문 (AskUserQuestion의 questions 배열 항목)
+ */
+export interface Question {
+    question: string;
+    header?: string;
+    options: QuestionOption[];
+    multiSelect?: boolean;
+}
+export interface QuestionOption {
+    label: string;
+    description?: string;
+}

package/dist/types/conversation.js

@@ -0,0 +1,4 @@
+/**
+ * 질문 관련 타입 정의
+ */
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./slack.js";
+export * from "./conversation.js";

package/dist/types/index.js

@@ -0,0 +1,2 @@
+export * from "./slack.js";
+export * from "./conversation.js";

package/dist/types/slack.d.ts

@@ -0,0 +1,51 @@
+export interface SelectedOptionValue {
+    questionIndex: number;
+    optionIndex: number;
+    label: string;
+    isMultiSelect: boolean;
+    projectName: string;
+    messageId: string;
+}
+export interface ToggleOptionValue {
+    questionIndex: number;
+    optionIndex: number;
+    label: string;
+    projectName: string;
+    messageId: string;
+}
+export interface SubmitMultiSelectValue {
+    questionIndex: number;
+    projectName: string;
+    messageId: string;
+}
+export interface TextInputButtonValue {
+    questionIndex: number;
+    type: "text_input";
+    projectName: string;
+    messageId: string;
+}
+export interface TextInputModalMetadata {
+    requestId: string;
+    questionIndex: number;
+    channelId: string;
+    messageTs: string;
+    threadTs: string;
+}
+export interface AutopilotInterruptValue {
+    threadTs: string;
+    channelId: string;
+    projectName: string;
+    userMessageTs?: string;
+}
+export interface StoredQuestionPayload {
+    questionText: string;
+    header?: string;
+    optionLabels?: string[];
+}
+export interface InitDirSelectValue {
+    dirName: string;
+}
+export interface InitCustomDirModalMetadata {
+    channelId: string;
+    originalMessageTs: string;
+}

package/dist/types/slack.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/display-width.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 문자열의 "표시 너비"를 대략 계산한다.
+ *
+ * - CJK/전각/이모지 계열은 2칸으로, variation selector는 0칸으로 본다.
+ * - 그 외 문자는 1칸으로 계산한다.
+ * - CLI 박스/정렬용 간이 계산이므로 완전한 유니코드 폭 구현은 아니다.
+ */
+export declare function getDisplayWidth(str: string): number;

package/dist/utils/display-width.js

@@ -0,0 +1,33 @@
+/**
+ * 문자열의 "표시 너비"를 대략 계산한다.
+ *
+ * - CJK/전각/이모지 계열은 2칸으로, variation selector는 0칸으로 본다.
+ * - 그 외 문자는 1칸으로 계산한다.
+ * - CLI 박스/정렬용 간이 계산이므로 완전한 유니코드 폭 구현은 아니다.
+ */
+export function getDisplayWidth(str) {
+    let width = 0;
+    for (const char of str) {
+        const code = char.codePointAt(0);
+        // Variation selectors are zero-width
+        if (code >= 0xfe00 && code <= 0xfe0f) {
+            continue;
+        }
+        if ((code >= 0x1100 && code <= 0x115f) ||
+            (code >= 0x2e80 && code <= 0x9fff) ||
+            (code >= 0xac00 && code <= 0xd7af) ||
+            (code >= 0xf900 && code <= 0xfaff) ||
+            (code >= 0xfe30 && code <= 0xfe6f) ||
+            (code >= 0xff01 && code <= 0xff60) ||
+            (code >= 0xffe0 && code <= 0xffe6) || // Fullwidth forms (currency, arrows)
+            (code >= 0x3300 && code <= 0x33ff) || // CJK Compatibility
+            (code >= 0x1f300 && code <= 0x1f9ff) || // Emoji ranges (commonly width 2)
+            (code >= 0x20000 && code <= 0x2fa1f)) {
+            width += 2;
+        }
+        else {
+            width += 1;
+        }
+    }
+    return width;
+}

package/dist/utils/safe-async.d.ts

@@ -0,0 +1,6 @@
+/**
+ * async EventEmitter 콜백을 try-catch로 감싸는 래퍼.
+ * EventEmitter는 async 콜백의 rejection을 자동 처리하지 않으므로,
+ * 이 래퍼를 사용하여 unhandledRejection을 방지한다.
+ */
+export declare function safeAsync<T extends unknown[]>(handler: (...args: T) => Promise<void>, context: string): (...args: T) => void;

package/dist/utils/safe-async.js

@@ -0,0 +1,14 @@
+import { createLogger } from "../core/logger.js";
+const log = createLogger("safe-async");
+/**
+ * async EventEmitter 콜백을 try-catch로 감싸는 래퍼.
+ * EventEmitter는 async 콜백의 rejection을 자동 처리하지 않으므로,
+ * 이 래퍼를 사용하여 unhandledRejection을 방지한다.
+ */
+export function safeAsync(handler, context) {
+    return (...args) => {
+        handler(...args).catch((error) => {
+            log.error(`Error in async handler [${context}]`, error);
+        });
+    };
+}

package/dist/utils/slack-message.d.ts

@@ -0,0 +1,73 @@
+import type { WebClient } from "@slack/web-api";
+import type { Question } from "../types/conversation.js";
+/**
+ * Slack 메시지 텍스트 최대 길이.
+ * Slack은 40,000자에서 메시지를 잘라내므로 약간의 여유를 두고 39,000자로 설정.
+ */
+export declare const SLACK_MAX_TEXT_LENGTH = 39000;
+/**
+ * 텍스트에서 열린(닫히지 않은) 코드 펜스가 있는지 확인.
+ * 열린 코드 펜스가 있으면 해당 펜스의 언어 식별자를 반환, 없으면 null.
+ */
+export declare function getUnclosedCodeFence(text: string): string | null;
+/**
+ * 긴 텍스트를 Slack 메시지 길이 제한에 맞게 분할.
+ * 가능하면 단락 경계(\n\n), 줄바꿈(\n) 순으로 자연스러운 위치에서 분할.
+ * 코드 블록(```)이 분할로 깨지면 자동으로 닫고 다음 청크에서 다시 열어줌.
+ */
+export declare function splitText(text: string, maxLength?: number): string[];
+export type PostMessageResult = {
+    success: true;
+    ts: string | undefined;
+} | {
+    success: false;
+    error: unknown;
+};
+/**
+ * 스레드에 메시지 전송.
+ * Slack 메시지 길이 제한(40,000자)을 초과하면 자동으로 분할 전송.
+ */
+export declare function postThreadMessage(client: WebClient, channelId: string, text: string, threadTs: string): Promise<PostMessageResult>;
+/**
+ * 채널에 메시지 전송 (스레드 없음)
+ */
+export declare function postChannelMessage(client: WebClient, channelId: string, text: string): Promise<PostMessageResult>;
+interface UpdateSlackMessageOptions {
+    client: WebClient;
+    channelId: string;
+    ts: string;
+    projectName: string;
+    messageId: string;
+    question: Question;
+    /** 선택된 답변 (완료 시) */
+    selectedAnswer?: string;
+    isSubmitted: boolean;
+}
+/**
+ * Slack 메시지 업데이트 (버튼 클릭 후 상태 반영)
+ */
+export declare function updateSlackMessage(options: UpdateSlackMessageOptions): Promise<void>;
+interface UpdateMultiSelectOptions {
+    client: WebClient;
+    channelId: string;
+    ts: string;
+    projectName: string;
+    messageId: string;
+    selectedOptionIndexes: number[];
+}
+/**
+ * 복수 선택 토글 후 Slack 메시지 업데이트
+ * multi-select-state에서 옵션 정보를 가져와서 blocks 재생성
+ */
+export declare function updateSlackMessageWithMultiSelect(options: UpdateMultiSelectOptions): Promise<void>;
+/**
+ * 메시지에 이모지 리액션 추가
+ * already_reacted 에러는 무시
+ */
+export declare function addReaction(client: WebClient, channelId: string, ts: string, emoji: string): Promise<void>;
+/**
+ * 메시지에서 이모지 리액션 제거
+ * no_reaction 에러는 무시
+ */
+export declare function removeReaction(client: WebClient, channelId: string, ts: string, emoji: string): Promise<void>;
+export {};

package/dist/utils/slack-message.js

@@ -0,0 +1,220 @@
+import { buildQuestionBlocks } from "../slack/question-blocks.js";
+import { createLogger } from "../core/logger.js";
+import { t } from "../i18n/index.js";
+import { getState } from "../stores/multi-select-state.js";
+import { withRetry } from "./slack-rate-limit.js";
+const log = createLogger("slack-message");
+/**
+ * Slack 메시지 텍스트 최대 길이.
+ * Slack은 40,000자에서 메시지를 잘라내므로 약간의 여유를 두고 39,000자로 설정.
+ */
+export const SLACK_MAX_TEXT_LENGTH = 39_000;
+/**
+ * 텍스트에서 열린(닫히지 않은) 코드 펜스가 있는지 확인.
+ * 열린 코드 펜스가 있으면 해당 펜스의 언어 식별자를 반환, 없으면 null.
+ */
+export function getUnclosedCodeFence(text) {
+    const fenceRegex = /^[ \t]*```(\S*)/gm;
+    let isOpen = false;
+    let lang = "";
+    let match;
+    while ((match = fenceRegex.exec(text)) !== null) {
+        if (!isOpen) {
+            isOpen = true;
+            lang = match[1] || "";
+        }
+        else {
+            isOpen = false;
+            lang = "";
+        }
+    }
+    return isOpen ? lang : null;
+}
+/**
+ * 분할로 깨진 코드 블록을 수정.
+ * 열린 코드 블록이 있는 청크에 닫는 펜스를 추가하고,
+ * 다음 청크에 여는 펜스를 추가.
+ */
+function repairCodeBlocks(chunks) {
+    if (chunks.length <= 1)
+        return chunks;
+    const result = [];
+    let pendingOpen = "";
+    for (let i = 0; i < chunks.length; i++) {
+        let chunk = pendingOpen + chunks[i];
+        pendingOpen = "";
+        if (i < chunks.length - 1) {
+            const lang = getUnclosedCodeFence(chunk);
+            if (lang !== null) {
+                chunk += "\n```";
+                pendingOpen = "```" + lang + "\n";
+            }
+        }
+        result.push(chunk);
+    }
+    return result;
+}
+/**
+ * 긴 텍스트를 Slack 메시지 길이 제한에 맞게 분할.
+ * 가능하면 단락 경계(\n\n), 줄바꿈(\n) 순으로 자연스러운 위치에서 분할.
+ * 코드 블록(```)이 분할로 깨지면 자동으로 닫고 다음 청크에서 다시 열어줌.
+ */
+export function splitText(text, maxLength = SLACK_MAX_TEXT_LENGTH) {
+    if (text.length <= maxLength)
+        return [text];
+    const chunks = [];
+    let remaining = text;
+    while (remaining.length > 0) {
+        if (remaining.length <= maxLength) {
+            chunks.push(remaining);
+            break;
+        }
+        // 단락 경계(\n\n)에서 분할 시도
+        let splitIndex = remaining.lastIndexOf("\n\n", maxLength);
+        if (splitIndex <= 0) {
+            // 줄바꿈(\n)에서 분할 시도
+            splitIndex = remaining.lastIndexOf("\n", maxLength);
+        }
+        if (splitIndex <= 0) {
+            // 자연스러운 분할 지점이 없으면 강제 분할
+            splitIndex = maxLength;
+        }
+        chunks.push(remaining.slice(0, splitIndex));
+        remaining = remaining.slice(splitIndex).replace(/^\n+/, "");
+    }
+    return repairCodeBlocks(chunks);
+}
+/**
+ * 스레드에 메시지 전송.
+ * Slack 메시지 길이 제한(40,000자)을 초과하면 자동으로 분할 전송.
+ */
+export async function postThreadMessage(client, channelId, text, threadTs) {
+    if (!text) {
+        log.warn("Skipping empty message", { channelId, threadTs });
+        return { success: true, ts: undefined };
+    }
+    try {
+        const chunks = splitText(text);
+        let lastTs;
+        for (const chunk of chunks) {
+            const result = await withRetry(() => client.chat.postMessage({
+                channel: channelId,
+                text: chunk,
+                thread_ts: threadTs,
+            }));
+            lastTs = result.ts;
+        }
+        return { success: true, ts: lastTs };
+    }
+    catch (error) {
+        log.error("Failed to post thread message", { error, channelId, threadTs });
+        return { success: false, error };
+    }
+}
+/**
+ * 채널에 메시지 전송 (스레드 없음)
+ */
+export async function postChannelMessage(client, channelId, text) {
+    try {
+        const result = await withRetry(() => client.chat.postMessage({
+            channel: channelId,
+            text,
+        }));
+        return { success: true, ts: result.ts };
+    }
+    catch (error) {
+        log.error("Failed to post channel message", error);
+        return { success: false, error };
+    }
+}
+/**
+ * Slack 메시지 업데이트 (버튼 클릭 후 상태 반영)
+ */
+export async function updateSlackMessage(options) {
+    const { client, channelId, ts, projectName, messageId, question, selectedAnswer, isSubmitted, } = options;
+    const blocks = buildQuestionBlocks({
+        question,
+        projectName,
+        messageId,
+        selectedAnswer,
+        isSubmitted,
+    });
+    try {
+        await withRetry(() => client.chat.update({
+            channel: channelId,
+            ts,
+            text: isSubmitted ? t("slack.answered") : t("slack.question"),
+            blocks,
+        }));
+    }
+    catch (error) {
+        log.error("Failed to update message", error);
+    }
+}
+/**
+ * 복수 선택 토글 후 Slack 메시지 업데이트
+ * multi-select-state에서 옵션 정보를 가져와서 blocks 재생성
+ */
+export async function updateSlackMessageWithMultiSelect(options) {
+    const { client, channelId, ts, projectName, messageId, selectedOptionIndexes, } = options;
+    // 상태에서 옵션 정보 가져오기
+    const state = getState(projectName, messageId);
+    if (!state) {
+        log.error("Multi-select state not found", { projectName, messageId });
+        return;
+    }
+    const question = {
+        question: state.questionText,
+        header: state.header,
+        options: state.options,
+        multiSelect: true,
+    };
+    const blocks = buildQuestionBlocks({
+        question,
+        projectName,
+        messageId,
+        isSubmitted: false,
+        selectedOptionIndexes,
+    });
+    try {
+        await withRetry(() => client.chat.update({
+            channel: channelId,
+            ts,
+            text: t("slack.question"),
+            blocks,
+        }));
+    }
+    catch (error) {
+        log.error("Failed to update multi-select message", error);
+    }
+}
+/**
+ * 메시지에 이모지 리액션 추가
+ * already_reacted 에러는 무시
+ */
+export async function addReaction(client, channelId, ts, emoji) {
+    try {
+        await withRetry(() => client.reactions.add({ channel: channelId, timestamp: ts, name: emoji }));
+    }
+    catch (error) {
+        const slackError = error;
+        if (slackError.data?.error === "already_reacted")
+            return;
+        log.error("Failed to add reaction", { error, channelId, ts, emoji });
+    }
+}
+/**
+ * 메시지에서 이모지 리액션 제거
+ * no_reaction 에러는 무시
+ */
+export async function removeReaction(client, channelId, ts, emoji) {
+    try {
+        await withRetry(() => client.reactions.remove({ channel: channelId, timestamp: ts, name: emoji }));
+    }
+    catch (error) {
+        const slackError = error;
+        if (slackError.data?.error === "no_reaction")
+            return;
+        log.error("Failed to remove reaction", { error, channelId, ts, emoji });
+    }
+}

package/dist/utils/slack-rate-limit.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Slack API 호출을 429 (rate_limited) 에러에 대해 자동 재시도하는 래퍼.
+ * Slack의 Retry-After 값을 존중하며, 최대 maxRetries 회까지 재시도.
+ */
+export declare function withRetry<T>(fn: () => Promise<T>, maxRetries?: number): Promise<T>;

package/dist/utils/slack-rate-limit.js

@@ -0,0 +1,49 @@
+import { createLogger } from "../core/logger.js";
+const log = createLogger("slack-rate-limit");
+const DEFAULT_MAX_RETRIES = 3;
+/**
+ * Slack API 호출을 429 (rate_limited) 에러에 대해 자동 재시도하는 래퍼.
+ * Slack의 Retry-After 값을 존중하며, 최대 maxRetries 회까지 재시도.
+ */
+export async function withRetry(fn, maxRetries = DEFAULT_MAX_RETRIES) {
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            const isRateLimited = isRateLimitedError(error);
+            if (!isRateLimited || attempt === maxRetries) {
+                throw error;
+            }
+            const retryAfterSec = parseRetryAfter(error) ?? 1;
+            const waitMs = retryAfterSec * 1000;
+            log.warn("Rate limited by Slack, retrying", {
+                attempt: attempt + 1,
+                maxRetries,
+                waitMs,
+            });
+            await sleep(waitMs);
+        }
+    }
+    // TypeScript needs this, but it's unreachable
+    throw new Error("withRetry: exhausted retries");
+}
+function isRateLimitedError(error) {
+    const err = error;
+    return err?.data?.error === "rate_limited";
+}
+function parseRetryAfter(error) {
+    const err = error;
+    if (typeof err?.retryAfter === "number")
+        return err.retryAfter;
+    const header = err?.headers?.["retry-after"] ?? err?.headers?.["Retry-After"];
+    if (header) {
+        const parsed = parseInt(header, 10);
+        if (!isNaN(parsed))
+            return parsed;
+    }
+    return null;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/workspace-store.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Workspace Store
+ *
+ * /twindevbot goto 로 생성된 스레드와 작업 디렉토리의 매핑을 관리합니다.
+ * 스레드에 첫 메시지가 오면 이 매핑을 사용하여 Claude 세션을 시작합니다.
+ *
+ * 키: threadTs (Slack 스레드 부모 메시지 타임스탬프)
+ * 값: { directory, projectName, channelId }
+ */
+export interface Workspace {
+    directory: string;
+    projectName: string;
+    channelId: string;
+    autopilot?: boolean;
+    createdAt?: Date;
+}
+export declare function addWorkspace(threadTs: string, workspace: Workspace): void;
+export declare function getWorkspace(threadTs: string): Workspace | undefined;
+export declare function removeWorkspace(threadTs: string): void;
+/**
+ * 정리 타이머 중지 (주로 테스트용)
+ */
+export declare function stopCleanupTimer(): void;
+/**
+ * 테스트용: cleanup 수동 실행
+ */
+export declare function runCleanup(): number;