@pollit/twin-dev-bot 0.0.1

package/dist/stores/pending-questions.js

@@ -0,0 +1,139 @@
+/**
+ * 복수 질문 배치 관리
+ *
+ * Claude의 AskUserQuestion이 여러 질문을 동시에 보낼 때,
+ * Slack에서는 한 번에 하나씩 표시하고 모든 답변을 수집한 후
+ * 조합하여 Claude에 전달합니다.
+ *
+ * 키: threadTs (스레드당 하나의 배치)
+ */
+import { createLogger } from "../core/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/stores/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;

package/dist/stores/workspace-store.js

@@ -0,0 +1,160 @@
+/**
+ * Workspace Store
+ *
+ * /twindevbot goto 로 생성된 스레드와 작업 디렉토리의 매핑을 관리합니다.
+ * 스레드에 첫 메시지가 오면 이 매핑을 사용하여 Claude 세션을 시작합니다.
+ *
+ * 키: threadTs (Slack 스레드 부모 메시지 타임스탬프)
+ * 값: { directory, projectName, channelId }
+ */
+import { existsSync, readFileSync, writeFileSync, renameSync } from "fs";
+import { createLogger } from "../core/logger.js";
+import { WORKSPACES_FILE } from "../core/paths.js";
+const log = createLogger("workspace-store");
+const workspaces = new Map();
+let cleanupInterval = null;
+// 24시간이 지난 워크스페이스는 자동 삭제
+const MAX_AGE_MS = 24 * 60 * 60 * 1000;
+function loadFromFile() {
+    try {
+        if (!existsSync(WORKSPACES_FILE)) {
+            log.info("No workspaces file found, starting fresh");
+            return;
+        }
+        const content = readFileSync(WORKSPACES_FILE, "utf-8");
+        let data;
+        try {
+            data = JSON.parse(content);
+        }
+        catch (parseError) {
+            log.error("Workspaces file is corrupted, starting fresh", { parseError });
+            return;
+        }
+        if (!data.workspaces || !Array.isArray(data.workspaces)) {
+            log.error("Workspaces file has invalid structure, starting fresh");
+            return;
+        }
+        let loadedCount = 0;
+        for (const w of data.workspaces) {
+            try {
+                workspaces.set(w.threadTs, {
+                    directory: w.directory,
+                    projectName: w.projectName,
+                    channelId: w.channelId,
+                    autopilot: w.autopilot,
+                    createdAt: w.createdAt ? new Date(w.createdAt) : new Date(),
+                });
+                loadedCount++;
+            }
+            catch (entryError) {
+                log.warn("Skipping invalid workspace entry", { entry: w, error: entryError });
+            }
+        }
+        log.info("Workspaces loaded from file", { count: loadedCount, total: data.workspaces.length });
+    }
+    catch (error) {
+        log.error("Failed to load workspaces from file", { error });
+    }
+}
+function saveToFile() {
+    try {
+        const serialized = Array.from(workspaces.entries()).map(([threadTs, w]) => ({
+            threadTs,
+            directory: w.directory,
+            projectName: w.projectName,
+            channelId: w.channelId,
+            autopilot: w.autopilot ?? undefined,
+            createdAt: w.createdAt?.toISOString(),
+        }));
+        const data = {
+            version: 1,
+            workspaces: serialized,
+        };
+        const tmpFile = WORKSPACES_FILE + ".tmp";
+        writeFileSync(tmpFile, JSON.stringify(data, null, 2));
+        renameSync(tmpFile, WORKSPACES_FILE);
+        log.debug("Workspaces saved to file", { count: serialized.length });
+    }
+    catch (error) {
+        log.error("Failed to save workspaces to file", { error });
+    }
+}
+// 모듈 로드 시 파일에서 복원
+loadFromFile();
+// 정리 타이머 시작
+function startCleanupTimer() {
+    if (cleanupInterval)
+        return;
+    // 매 시간마다 실행 (첫 실행은 1시간 후)
+    cleanupInterval = setInterval(() => {
+        cleanup();
+    }, 60 * 60 * 1000);
+    cleanupInterval.unref();
+    log.debug("Workspace cleanup timer started (runs every hour)");
+}
+startCleanupTimer();
+export function addWorkspace(threadTs, workspace) {
+    // createdAt이 없으면 현재 시간으로 설정
+    if (!workspace.createdAt) {
+        workspace.createdAt = new Date();
+    }
+    workspaces.set(threadTs, workspace);
+    log.info("Workspace registered", {
+        threadTs,
+        projectName: workspace.projectName,
+        directory: workspace.directory,
+    });
+    saveToFile();
+}
+export function getWorkspace(threadTs) {
+    return workspaces.get(threadTs);
+}
+export function removeWorkspace(threadTs) {
+    workspaces.delete(threadTs);
+    log.debug("Workspace removed", { threadTs });
+    saveToFile();
+}
+/**
+ * 오래된 워크스페이스 정리 (createdAt 기준)
+ */
+function cleanup() {
+    const now = Date.now();
+    let cleanedCount = 0;
+    for (const [threadTs, workspace] of workspaces.entries()) {
+        // createdAt이 없는 항목은 건너뜀 (레거시 데이터)
+        if (!workspace.createdAt) {
+            continue;
+        }
+        const ageMs = now - workspace.createdAt.getTime();
+        if (ageMs > MAX_AGE_MS) {
+            workspaces.delete(threadTs);
+            cleanedCount++;
+            log.info("Workspace expired", {
+                threadTs,
+                projectName: workspace.projectName,
+                ageDays: Math.floor(ageMs / (24 * 60 * 60 * 1000)),
+            });
+        }
+    }
+    if (cleanedCount > 0) {
+        saveToFile();
+        log.info("Workspace cleanup completed", { cleanedCount, remaining: workspaces.size });
+    }
+    return cleanedCount;
+}
+/**
+ * 정리 타이머 중지 (주로 테스트용)
+ */
+export function stopCleanupTimer() {
+    if (cleanupInterval) {
+        clearInterval(cleanupInterval);
+        cleanupInterval = null;
+        log.debug("Workspace cleanup timer stopped");
+    }
+}
+/**
+ * 테스트용: cleanup 수동 실행
+ */
+export function runCleanup() {
+    return cleanup();
+}

package/dist/templates.d.ts

@@ -0,0 +1,23 @@
+export interface FrameworkTemplate {
+    name: string;
+    category: "frontend" | "backend";
+    /**
+     * scaffold 명령어 또는 Node.js 함수를 반환.
+     * - string: 셸 명령어 (cwd가 BASE_DIR인 상태에서 실행됨)
+     * - (cwd: string) => Promise<void>: Node.js API로 직접 수행 (크로스 플랫폼)
+     */
+    scaffold: (projectName: string) => string | ((cwd: string) => Promise<void>);
+    /** scaffold 실행 타임아웃 (ms). 미지정 시 DEFAULT_SCAFFOLD_TIMEOUT 적용 */
+    timeout?: number;
+}
+/** 기본 scaffold 타임아웃: 5분 */
+export declare const DEFAULT_SCAFFOLD_TIMEOUT = 300000;
+export declare const TEMPLATES: Record<string, FrameworkTemplate>;
+/**
+ * 템플릿 조회
+ */
+export declare function getTemplate(key: string): FrameworkTemplate | undefined;
+/**
+ * 사용 가능한 템플릿 목록 (카테고리별 그룹)
+ */
+export declare function getTemplateListText(): string;

package/dist/templates.js

@@ -0,0 +1,292 @@
+/**
+ * 프로젝트 템플릿 정의
+ *
+ * /twindevbot new <directory> --template <key> 에서 사용.
+ * 각 프레임워크의 공식 scaffold CLI 커맨드를 정의합니다.
+ */
+import { execSync } from "child_process";
+import { createWriteStream, mkdirSync, unlinkSync, writeFileSync } from "fs";
+import https from "https";
+import { tmpdir } from "os";
+import { join } from "path";
+import { t } from "./i18n/index.js";
+/** 기본 scaffold 타임아웃: 5분 */
+export const DEFAULT_SCAFFOLD_TIMEOUT = 300_000;
+const MAX_REDIRECTS = 10;
+/** 다운로드 요청 타임아웃: 30초 */
+const DOWNLOAD_TIMEOUT_MS = 30_000;
+/**
+ * URL에서 파일을 다운로드 (리다이렉트 지원, 최대 MAX_REDIRECTS 회)
+ */
+function downloadFile(url, destPath) {
+    return new Promise((resolve, reject) => {
+        const request = (targetUrl, redirectCount) => {
+            if (redirectCount > MAX_REDIRECTS) {
+                reject(new Error(`Too many redirects (max ${MAX_REDIRECTS})`));
+                return;
+            }
+            const req = https.get(targetUrl, { timeout: DOWNLOAD_TIMEOUT_MS }, (res) => {
+                if (res.statusCode === 301 || res.statusCode === 302 || res.statusCode === 307 || res.statusCode === 308) {
+                    const location = res.headers.location;
+                    if (!location) {
+                        reject(new Error("Redirect without location header"));
+                        return;
+                    }
+                    res.resume();
+                    const resolved = new URL(location, targetUrl).href;
+                    request(resolved, redirectCount + 1);
+                    return;
+                }
+                if (res.statusCode !== 200) {
+                    res.resume();
+                    reject(new Error(`HTTP ${res.statusCode}`));
+                    return;
+                }
+                const file = createWriteStream(destPath);
+                res.pipe(file);
+                file.on("finish", () => { file.close(() => resolve()); });
+                file.on("error", reject);
+            });
+            req.on("timeout", () => {
+                req.destroy();
+                reject(new Error(`Download timed out after ${DOWNLOAD_TIMEOUT_MS}ms: ${targetUrl}`));
+            });
+            req.on("error", reject);
+        };
+        request(url, 0);
+    });
+}
+// ─────────────────────────────────────────────────────────────────────────
+// Defence-in-depth: scaffold 함수 내부에서도 프로젝트 이름을 검증
+// ─────────────────────────────────────────────────────────────────────────
+const SAFE_PROJECT_NAME_RE = /^[a-zA-Z0-9._-]+$/;
+function assertSafeProjectName(name) {
+    if (name === "." || name === "..") {
+        throw new Error(`Unsafe project name: "${name}". Directory traversal names are not allowed.`);
+    }
+    if (name.startsWith("-")) {
+        throw new Error(`Unsafe project name: "${name}". Names starting with "-" are not allowed.`);
+    }
+    if (!SAFE_PROJECT_NAME_RE.test(name)) {
+        throw new Error(`Unsafe project name: "${name}". Only alphanumeric characters, dots, hyphens, and underscores are allowed.`);
+    }
+}
+export const TEMPLATES = {
+    // ── Frontend ──────────────────────────────────────────────
+    react: {
+        name: "React (Vite + TypeScript)",
+        category: "frontend",
+        scaffold: (name) => {
+            assertSafeProjectName(name);
+            return `npm create vite@latest ${name} -- --template react-ts --no-interactive`;
+        },
+    },
+    nextjs: {
+        name: "Next.js",
+        category: "frontend",
+        scaffold: (name) => {
+            assertSafeProjectName(name);
+            return `npx create-next-app@latest ${name} --yes --ts --eslint --app --src-dir --tailwind --import-alias "@/*" --use-npm`;
+        },
+        timeout: 600_000,
+    },
+    vue: {
+        name: "Vue (create-vue)",
+        category: "frontend",
+        scaffold: (name) => {
+            assertSafeProjectName(name);
+            return `npm create vue@latest ${name} -- --ts --router --pinia --eslint --prettier`;
+        },
+    },
+    nuxt: {
+        name: "Nuxt",
+        category: "frontend",
+        scaffold: (name) => {
+            assertSafeProjectName(name);
+            return `npx nuxi@latest init ${name} --template v4-compat --gitInit false --packageManager npm --no-modules`;
+        },
+    },
+    sveltekit: {
+        name: "SvelteKit",
+        category: "frontend",
+        scaffold: (name) => {
+            assertSafeProjectName(name);
+            return `npx sv create ${name} --template minimal --types ts --no-add-ons --no-install`;
+        },
+    },
+    angular: {
+        name: "Angular",
+        category: "frontend",
+        scaffold: (name) => {
+            assertSafeProjectName(name);
+            return `npx @angular/cli@latest new ${name} --defaults --skip-install --no-interactive`;
+        },
+    },
+    "react-native-expo": {
+        name: "React Native (Expo)",
+        category: "frontend",
+        scaffold: (name) => {
+            assertSafeProjectName(name);
+            return `npx create-expo-app@latest ${name} --template blank-typescript --yes`;
+        },
+        timeout: 600_000,
+    },
+    "react-native-bare": {
+        name: "React Native (Bare CLI)",
+        category: "frontend",
+        scaffold: (name) => {
+            assertSafeProjectName(name);
+            // React Native CLI requires PascalCase project names (no hyphens)
+            const pascalName = name
+                .split(/[-_]+/)
+                .map((s) => s.charAt(0).toUpperCase() + s.slice(1))
+                .join("");
+            return `npx @react-native-community/cli@latest init ${pascalName} --directory ${name}`;
+        },
+        timeout: 600_000,
+    },
+    flutter: {
+        name: "Flutter",
+        category: "frontend",
+        scaffold: (name) => {
+            assertSafeProjectName(name);
+            return `flutter create ${name}`;
+        },
+    },
+    // ── Backend ───────────────────────────────────────────────
+    express: {
+        name: "Express",
+        category: "backend",
+        scaffold: (name) => {
+            assertSafeProjectName(name);
+            return `npx express-generator ${name} --no-view`;
+        },
+    },
+    nestjs: {
+        name: "NestJS",
+        category: "backend",
+        scaffold: (name) => {
+            assertSafeProjectName(name);
+            return `npx @nestjs/cli@latest new ${name} --package-manager npm --skip-install --skip-git`;
+        },
+    },
+    fastify: {
+        name: "Fastify (TypeScript)",
+        category: "backend",
+        scaffold: (name) => {
+            assertSafeProjectName(name);
+            return `npx fastify-cli generate ${name} --lang=ts`;
+        },
+    },
+    "spring-boot": {
+        name: "Spring Boot",
+        category: "backend",
+        scaffold: (name) => {
+            assertSafeProjectName(name);
+            return async (cwd) => {
+                const zipPath = join(tmpdir(), `spring-${name}.zip`);
+                const safePkgName = name.replace(/-/g, "_");
+                const enc = encodeURIComponent;
+                const url = `https://start.spring.io/starter.zip?type=maven-project&language=java&baseDir=${enc(name)}&groupId=com.example&artifactId=${enc(name)}&name=${enc(name)}&packageName=${enc(`com.example.${safePkgName}`)}&dependencies=web`;
+                try {
+                    await downloadFile(url, zipPath);
+                    if (process.platform === "win32") {
+                        execSync(`powershell -Command "Expand-Archive -Path '${zipPath}' -DestinationPath '.' -Force"`, { cwd });
+                    }
+                    else {
+                        execSync(`unzip -q "${zipPath}" -d .`, { cwd });
+                    }
+                }
+                finally {
+                    try {
+                        unlinkSync(zipPath);
+                    }
+                    catch { /* 파일이 없을 수 있음 */ }
+                }
+            };
+        },
+        timeout: 600_000,
+    },
+    django: {
+        name: "Django",
+        category: "backend",
+        scaffold: (name) => {
+            assertSafeProjectName(name);
+            return `django-admin startproject ${name}`;
+        },
+    },
+    fastapi: {
+        name: "FastAPI",
+        category: "backend",
+        scaffold: (name) => {
+            assertSafeProjectName(name);
+            return async (cwd) => {
+                const dir = join(cwd, name);
+                mkdirSync(dir, { recursive: true });
+                writeFileSync(join(dir, "main.py"), [
+                    "from fastapi import FastAPI",
+                    "",
+                    "app = FastAPI()",
+                    "",
+                    "",
+                    '@app.get("/")',
+                    "def read_root():",
+                    '    return {"Hello": "World"}',
+                    "",
+                ].join("\n"));
+            };
+        },
+    },
+    go: {
+        name: "Go (module)",
+        category: "backend",
+        scaffold: (name) => {
+            assertSafeProjectName(name);
+            return async (cwd) => {
+                const dir = join(cwd, name);
+                mkdirSync(dir, { recursive: true });
+                execSync(`go mod init example.com/${name}`, { cwd: dir });
+            };
+        },
+    },
+    rails: {
+        name: "Ruby on Rails (API)",
+        category: "backend",
+        scaffold: (name) => {
+            assertSafeProjectName(name);
+            return `rails new ${name} --skip-bundle --skip-git --api`;
+        },
+        timeout: 600_000,
+    },
+    laravel: {
+        name: "Laravel",
+        category: "backend",
+        scaffold: (name) => {
+            assertSafeProjectName(name);
+            return `composer create-project laravel/laravel ${name} --no-interaction --prefer-dist`;
+        },
+        timeout: 600_000,
+    },
+};
+/**
+ * 템플릿 조회
+ */
+export function getTemplate(key) {
+    return TEMPLATES[key.toLowerCase()];
+}
+/**
+ * 사용 가능한 템플릿 목록 (카테고리별 그룹)
+ */
+export function getTemplateListText() {
+    const grouped = {
+        frontend: [],
+        backend: [],
+    };
+    for (const [key, tmpl] of Object.entries(TEMPLATES)) {
+        grouped[tmpl.category].push(`\`${key}\``);
+    }
+    const lines = [];
+    lines.push("> " + t("template.frontend") + grouped.frontend.join(", "));
+    lines.push("> " + t("template.backend") + grouped.backend.join(", "));
+    return lines.join("\n");
+}