@pollit/twin-dev-bot 0.0.1

package/dist/logger.js

@@ -0,0 +1,110 @@
+import { createWriteStream } from "fs";
+const LOG_LEVELS = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+};
+function safeStringify(data) {
+    if (data instanceof Error) {
+        return JSON.stringify({ message: data.message, stack: data.stack });
+    }
+    try {
+        return JSON.stringify(data);
+    }
+    catch {
+        return "[unserializable]";
+    }
+}
+class Logger {
+    level;
+    context;
+    static logStream = null;
+    constructor(level = "info", context) {
+        this.level = level;
+        this.context = context;
+    }
+    static enableFileLogging(filePath) {
+        if (Logger.logStream) {
+            Logger.logStream.end();
+        }
+        Logger.logStream = createWriteStream(filePath, { flags: "a" });
+        Logger.logStream.on("error", (err) => {
+            console.error("Log file write error:", err.message);
+        });
+    }
+    shouldLog(level) {
+        return LOG_LEVELS[level] >= LOG_LEVELS[this.level];
+    }
+    formatMessage(level, message, data) {
+        const timestamp = new Date().toISOString();
+        const prefix = this.context ? `[${this.context}] ` : "";
+        const dataStr = data !== undefined ? ` ${safeStringify(data)}` : "";
+        return `${timestamp} ${level.toUpperCase().padEnd(5)} ${prefix}${message}${dataStr}`;
+    }
+    output(formatted) {
+        console.error(formatted);
+        Logger.logStream?.write(formatted + "\n");
+    }
+    debug(message, data) {
+        if (this.shouldLog("debug")) {
+            this.output(this.formatMessage("debug", message, data));
+        }
+    }
+    info(message, data) {
+        if (this.shouldLog("info")) {
+            this.output(this.formatMessage("info", message, data));
+        }
+    }
+    warn(message, data) {
+        if (this.shouldLog("warn")) {
+            this.output(this.formatMessage("warn", message, data));
+        }
+    }
+    error(message, error) {
+        if (this.shouldLog("error")) {
+            const errorData = error instanceof Error
+                ? { message: error.message, stack: error.stack }
+                : error;
+            this.output(this.formatMessage("error", message, errorData));
+        }
+    }
+    child(context) {
+        const childContext = this.context ? `${this.context}:${context}` : context;
+        return new Logger(this.level, childContext);
+    }
+}
+const VALID_LOG_LEVELS = new Set(Object.keys(LOG_LEVELS));
+function parseLogLevel(envValue) {
+    if (envValue && VALID_LOG_LEVELS.has(envValue)) {
+        return envValue;
+    }
+    if (envValue) {
+        console.error(`Invalid LOG_LEVEL "${envValue}". Valid values: ${[...VALID_LOG_LEVELS].join(", ")}. Falling back to "info".`);
+    }
+    return "info";
+}
+export const logger = new Logger(parseLogLevel(process.env.LOG_LEVEL));
+export function createLogger(context) {
+    return logger.child(context);
+}
+export function enableFileLogging(filePath) {
+    Logger.enableFileLogging(filePath);
+}
+/**
+ * Slack Bolt용 로거 어댑터.
+ * Bolt 내부 로그를 커스텀 로거로 라우팅하여
+ * 타임스탬프 + stderr 출력을 일관되게 유지한다.
+ */
+export function createBoltLogger() {
+    let boltLog = logger.child("bolt");
+    return {
+        debug(...msg) { boltLog.debug(msg.map(String).join(" ")); },
+        info(...msg) { boltLog.info(msg.map(String).join(" ")); },
+        warn(...msg) { boltLog.warn(msg.map(String).join(" ")); },
+        error(...msg) { boltLog.error(msg.map(String).join(" ")); },
+        setLevel() { },
+        getLevel() { return "info"; },
+        setName(name) { boltLog = logger.child(name); },
+    };
+}

package/dist/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/multi-select-state.js

@@ -0,0 +1,151 @@
+/**
+ * 복수 선택 상태 관리
+ *
+ * multiSelect가 true인 질문에서 사용자가 선택한 옵션들을
+ * "선택 완료" 버튼을 누르기 전까지 임시 저장합니다.
+ *
+ * 키: `${projectName}:${messageId}`
+ * 값: { selected: 선택된 옵션 인덱스 Set, options: 전체 옵션 배열 }
+ */
+import { createLogger } from "./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/paths.d.ts

@@ -0,0 +1,11 @@
+export declare const ENV_FILE: string;
+export declare const DATA_DIR: string;
+export declare const SESSIONS_FILE: string;
+export declare const WORKSPACES_FILE: string;
+export declare const CHANNELS_FILE: string;
+export declare const LOG_DIR: string;
+export declare const LOG_OUT: string;
+export declare const LOG_ERR: string;
+export declare const PID_FILE: string;
+/** DATA_DIR, LOG_DIR 가 없으면 생성. 서버/데몬 기동 시에만 호출할 것 */
+export declare function ensureDirs(): void;

package/dist/paths.js

@@ -0,0 +1,18 @@
+import { mkdirSync } from "fs";
+import { join } from "path";
+// 프로젝트 루트: 프로세스 실행 디렉토리 기준
+const PROJECT_ROOT = process.cwd();
+export const ENV_FILE = join(PROJECT_ROOT, ".env");
+export const DATA_DIR = join(PROJECT_ROOT, "data");
+export const SESSIONS_FILE = join(DATA_DIR, "sessions.json");
+export const WORKSPACES_FILE = join(DATA_DIR, "workspaces.json");
+export const CHANNELS_FILE = join(DATA_DIR, "channels.json");
+export const LOG_DIR = join(PROJECT_ROOT, "logs");
+export const LOG_OUT = join(LOG_DIR, "twindevbot.out.log");
+export const LOG_ERR = join(LOG_DIR, "twindevbot.err.log");
+export const PID_FILE = join(DATA_DIR, "twindevbot.pid");
+/** DATA_DIR, LOG_DIR 가 없으면 생성. 서버/데몬 기동 시에만 호출할 것 */
+export function ensureDirs() {
+    mkdirSync(DATA_DIR, { recursive: true });
+    mkdirSync(LOG_DIR, { recursive: true });
+}

package/dist/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;

package/dist/pending-questions.js

@@ -0,0 +1,139 @@
+/**
+ * 복수 질문 배치 관리
+ *
+ * Claude의 AskUserQuestion이 여러 질문을 동시에 보낼 때,
+ * Slack에서는 한 번에 하나씩 표시하고 모든 답변을 수집한 후
+ * 조합하여 Claude에 전달합니다.
+ *
+ * 키: threadTs (스레드당 하나의 배치)
+ */
+import { createLogger } from "./logger.js";
+const log = createLogger("pending-questions");
+const batchMap = new Map();
+// 1시간이 지난 배치는 자동 삭제 (정상적으로는 오래 걸리지 않음)
+const MAX_AGE_MS = 60 * 60 * 1000;
+let cleanupInterval = null;
+/**
+ * 배치 초기화 (questions.length > 1일 때 호출)
+ */
+export function initPendingBatch(threadTs, questions, projectName, channelId) {
+    batchMap.set(threadTs, {
+        questions,
+        answers: [],
+        currentIndex: 0,
+        projectName,
+        channelId,
+        createdAt: Date.now(),
+    });
+    log.info("Pending batch initialized", { threadTs, questionCount: questions.length });
+    // 타이머가 없으면 시작
+    ensureCleanupTimer();
+}
+/**
+ * 대기 중인 배치 존재 여부
+ */
+export function hasPendingBatch(threadTs) {
+    return batchMap.has(threadTs);
+}
+/**
+ * 답변 기록 후 다음 질문 반환.
+ * done=true이면 모든 질문에 답변 완료.
+ */
+export function recordAnswerAndAdvance(threadTs, answer) {
+    const batch = batchMap.get(threadTs);
+    if (!batch)
+        return null;
+    batch.answers.push(answer);
+    batch.currentIndex++;
+    if (batch.currentIndex >= batch.questions.length) {
+        return { done: true, batch };
+    }
+    return {
+        done: false,
+        nextQuestion: batch.questions[batch.currentIndex],
+        batch,
+    };
+}
+/**
+ * 모든 답변을 조합하여 Claude resume용 문자열 생성.
+ * 형식: "[header]: answer" (줄바꿈 구분)
+ * header가 없으면 질문 텍스트 앞 50자 사용.
+ */
+export function buildCombinedAnswer(threadTs) {
+    const batch = batchMap.get(threadTs);
+    if (!batch)
+        return null;
+    if (batch.questions.length === 1) {
+        return batch.answers[0] ?? null;
+    }
+    return batch.questions
+        .map((q, i) => {
+        const label = q.header || q.question.slice(0, 50);
+        const answer = batch.answers[i] ?? "";
+        return `[${label}]: ${answer}`;
+    })
+        .join("\n");
+}
+/**
+ * 배치 정리
+ */
+export function clearPendingBatch(threadTs) {
+    batchMap.delete(threadTs);
+    log.debug("Pending batch cleared", { threadTs });
+}
+/**
+ * 오래된 배치 정리
+ */
+function cleanup() {
+    const now = Date.now();
+    let cleanedCount = 0;
+    for (const [threadTs, batch] of batchMap.entries()) {
+        const ageMs = now - batch.createdAt;
+        if (ageMs > MAX_AGE_MS) {
+            batchMap.delete(threadTs);
+            cleanedCount++;
+            log.info("Pending batch expired", {
+                threadTs,
+                projectName: batch.projectName,
+                ageMinutes: Math.floor(ageMs / (60 * 1000)),
+                answeredCount: batch.answers.length,
+                totalCount: batch.questions.length,
+            });
+        }
+    }
+    if (cleanedCount > 0) {
+        log.info("Pending batch cleanup completed", { cleanedCount, remaining: batchMap.size });
+    }
+    return cleanedCount;
+}
+/**
+ * 정리 타이머 시작
+ */
+function ensureCleanupTimer() {
+    if (cleanupInterval)
+        return;
+    // 즉시 한 번 실행
+    cleanup();
+    // 매 시간마다 실행
+    cleanupInterval = setInterval(() => {
+        cleanup();
+    }, 60 * 60 * 1000);
+    cleanupInterval.unref();
+    log.debug("Pending batch cleanup timer started (runs every hour)");
+}
+/**
+ * 정리 타이머 중지 (주로 테스트용)
+ */
+export function stopCleanupTimer() {
+    if (cleanupInterval) {
+        clearInterval(cleanupInterval);
+        cleanupInterval = null;
+        log.debug("Pending batch cleanup timer stopped");
+    }
+}
+/**
+ * 테스트용: cleanup 수동 실행
+ */
+export function runCleanup() {
+    return cleanup();
+}

package/dist/platform.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Cross-platform home directory.
+ * Replaces all instances of: process.env.HOME || "/root"
+ */
+export declare function getHomeDir(): string;
+/**
+ * Cross-platform tilde expansion.
+ * Replaces ~/ (or ~\) with the user's home directory.
+ */
+export declare function expandTilde(p: string): string;
+/**
+ * Default base directory for projects.
+ */
+export declare function getDefaultBaseDir(): string;
+/**
+ * Whether the current platform supports daemon management.
+ */
+export declare function isDaemonSupported(): boolean;

package/dist/platform.js

@@ -0,0 +1,33 @@
+import { homedir } from "os";
+import { join } from "path";
+/**
+ * Cross-platform home directory.
+ * Replaces all instances of: process.env.HOME || "/root"
+ */
+export function getHomeDir() {
+    return homedir();
+}
+/**
+ * Cross-platform tilde expansion.
+ * Replaces ~/ (or ~\) with the user's home directory.
+ */
+export function expandTilde(p) {
+    if (p === "~")
+        return getHomeDir();
+    if (p.startsWith("~/") || p.startsWith("~\\")) {
+        return join(getHomeDir(), p.slice(2));
+    }
+    return p;
+}
+/**
+ * Default base directory for projects.
+ */
+export function getDefaultBaseDir() {
+    return join(getHomeDir(), "Desktop");
+}
+/**
+ * Whether the current platform supports daemon management.
+ */
+export function isDaemonSupported() {
+    return process.platform === "darwin" || process.platform === "win32";
+}

package/dist/progress-tracker.d.ts

@@ -0,0 +1,47 @@
+import type { WebClient } from "@slack/web-api";
+export interface ProgressTrackerOptions {
+    client: WebClient;
+    channelId: string;
+    threadTs: string;
+    userMessageTs?: string;
+}
+export declare class ProgressTracker {
+    private client;
+    private channelId;
+    private threadTs;
+    private userMessageTs?;
+    private statusMessageTs?;
+    private startTime;
+    private currentReaction?;
+    private static readonly THROTTLE_MS;
+    private lastUpdateTime;
+    private pendingUpdate;
+    private pendingUpdateTimer;
+    private disposed;
+    constructor(options: ProgressTrackerOptions);
+    /** 사용자 메시지에 👀 리액션 추가 (접수 확인) */
+    markReceived(): Promise<void>;
+    /** 작업 시작 — 👀→⚙️ 교체 + 상태 메시지 게시 */
+    markWorking(): Promise<void>;
+    /** 도구 사용 — 상태 메시지 갱신 (리액션 변경 없음, 5초 쓰로틀) */
+    updateToolUse(toolName: string): Promise<void>;
+    /** 작업 완료 — ⚙️→✅ 교체 + 상태 메시지 갱신 */
+    markCompleted(): Promise<void>;
+    /** 오류 — ⚙️→❌ 교체 + 상태 메시지 갱신 */
+    markError(errorMessage: string): Promise<void>;
+    /** 계획 승인 — ⚙️→👍 교체 + 상태 메시지 갱신 (구현 시작 전 전환 상태) */
+    markPlanApproved(): Promise<void>;
+    /** Autopilot 자동 응답 후 계속 진행 — 리액션 변경 없이 상태 메시지만 갱신 */
+    markAutopilotContinue(): Promise<void>;
+    /** 질문 전송 — ⚙️→✋ 교체 + 상태 메시지 갱신 */
+    markAskUser(): Promise<void>;
+    /** 타이머 정리 — 인스턴스를 더 이상 사용하지 않을 때 호출 */
+    dispose(): void;
+    private setReaction;
+    private swapReaction;
+    private postStatusMessage;
+    private updateStatusMessage;
+    private flushPendingUpdate;
+    private clearPendingUpdate;
+    private getElapsedText;
+}