すごろく型ロードマップ機能
実装仕様書

ANTHROPIC_API_KEY=sk-ant-...               # Anthropic APIキー（必須）
DATABASE_URL=postgresql://...              # DB接続文字列
NEXTAUTH_SECRET=...                        # 認証Secret（既存利用可）
# 任意: ロードマップ機能のフィーチャーフラグ
ROADMAP_FEATURE_ENABLED=true

// ==================
// ゴール（最上位）
// ==================
model Goal {
  id              String      @id @default(cuid())
  userId          String
  title           String      // 200字以内
  description     String?     @db.Text
  targetDate      DateTime?
  status          String      @default("active")  // active | completed | archived
  generatedBy     String      @default("ai")      // ai | manual
  generationModel String?                          // 例: "claude-haiku-4-5-20251001"
  createdAt       DateTime    @default(now())
  updatedAt       DateTime    @updatedAt
  completedAt     DateTime?
  user            User        @relation(fields: [userId], references: [id], onDelete: Cascade)
  milestones      Milestone[]

  @@index([userId])
  @@index([userId, status])
}

// ==================
// マイルストーン（中間）
// ==================
model Milestone {
  id          String        @id @default(cuid())
  goalId      String
  title       String
  description String?       @db.Text
  sortOrder   Int           @default(0)
  status      String        @default("locked")    // locked | active | completed
  completedAt DateTime?
  createdAt   DateTime      @default(now())
  updatedAt   DateTime      @updatedAt
  goal        Goal          @relation(fields: [goalId], references: [id], onDelete: Cascade)
  tasks       RoadmapTask[]

  @@index([goalId])
  @@index([goalId, sortOrder])
}

// ==================
// タスク（葉ノード）
// ==================
model RoadmapTask {
  id          String    @id @default(cuid())
  milestoneId String
  userId      String                              // denormalize: 完了連動・所有権チェック高速化
  type        String                              // lesson | task
  title       String
  description String?   @db.Text
  lessonId    String?                             // type=lesson の場合のみ
  sortOrder   Int       @default(0)
  isCompleted Boolean   @default(false)
  completedAt DateTime?
  source      String    @default("ai")            // ai | manual | chat
  createdAt   DateTime  @default(now())
  updatedAt   DateTime  @updatedAt
  milestone   Milestone @relation(fields: [milestoneId], references: [id], onDelete: Cascade)
  user        User      @relation(fields: [userId], references: [id], onDelete: Cascade)
  lesson      Lesson?   @relation(fields: [lessonId], references: [id], onDelete: SetNull)

  @@index([milestoneId])
  @@index([userId])
  @@index([userId, lessonId])
}

const GENERATION_MODEL    = "claude-haiku-4-5-20251001";
const MAX_LESSONS_IN_PROMPT = 60;        // プロンプトに含めるレッスン上限

// Phase 1 (clarify)
max_tokens: 3072
tool_choice: { type: "tool", name: "ask_questions" }

// Phase 2 (generate)
max_tokens: 4096
tool_choice: { type: "tool", name: "create_roadmap" }

{
  "name": "ask_questions",
  "description": "ゴール達成に必要な情報をヒアリングするための質問を、4セクション×3問の合計12問生成する。",
  "input_schema": {
    "type": "object",
    "properties": {
      "sections": {
        "type": "array",
        "description": "4つのセクション (current/goal/constraints/success)",
        "items": {
          "type": "object",
          "properties": {
            "key": {
              "type": "string",
              "enum": ["current", "goal", "constraints", "success"]
            },
            "title": { "type": "string" },
            "questions": {
              "type": "array",
              "items": {
                "type": "object",
                "properties": {
                  "question":    { "type": "string" },
                  "suggestions": { "type": "array", "items": { "type": "string" } }
                },
                "required": ["question", "suggestions"]
              }
            }
          },
          "required": ["key", "title", "questions"]
        }
      }
    },
    "required": ["sections"]
  }
}

{
  "name": "create_roadmap",
  "description": "ユーザーのゴールに対して、すごろく型のロードマップを作成する。既存レッスンと、必要に応じてカスタムタスクを組み合わせる。",
  "input_schema": {
    "type": "object",
    "properties": {
      "milestones": {
        "type": "array",
        "description": "ゴール達成までのマイルストーン（3〜6個推奨、簡単→難しい順）",
        "items": {
          "type": "object",
          "properties": {
            "title":       { "type": "string" },
            "description": { "type": "string" },
            "tasks": {
              "type": "array",
              "description": "このマイルストーンで完了すべきタスク（3〜6個）",
              "items": {
                "type": "object",
                "properties": {
                  "type":        { "type": "string", "enum": ["lesson", "task"] },
                  "title":       { "type": "string" },
                  "description": { "type": "string" },
                  "lessonId":    { "type": "string", "description": "type=lesson の場合に必須" }
                },
                "required": ["type", "title"]
              }
            }
          },
          "required": ["title", "tasks"]
        }
      }
    },
    "required": ["milestones"]
  }
}

ユーザーのゴールに対して、ロードマップを設計するための深い情報収集を行います。
4セクション×3問 = 計12問を、ユーザーの状況に応じて具体的に作成してください。

ゴール: ${goalTitle}
${goalDescription ? `詳細: ${goalDescription}` : ""}
${userContext ? `\n${userContext}` : ""}

セクション構成（必ずこの順で4つ）:
1. current  / "現在地"     ... 経験レベル・現状の課題・関連スキル
2. goal     / "ゴール詳細" ... 具体的なアウトプット・対象ユーザー・規模感
3. constraints / "制約"    ... 時間・予算・障害物
4. success  / "成功定義"   ... 完了基準・中間マイルストーン・根本動機

【最重要ルール】
- ゴール文面に明示されていない職業・業種・対象領域・既存ツールを勝手に仮定しない
- 例: ゴールが「Webアプリを作る」だけなら「不動産業向けですか？」など特定業種に絞った質問はNG
- ユーザーが「何のために」「どのレベルで」「どんな成果物を」を答えやすい中立的な質問にする

その他のルール:
- 質問は短く具体的に（1問あたり40字以内）
- suggestionsは3〜4個、短いフレーズ（10〜20字程度）、業種を限定しない汎用的な選択肢にする
- 「自由記述」は提示しない（フロント側で必ず追加される）

ask_questions ツールで返答してください。

あなたは学習コーチです。ユーザーのゴールに対して、すごろく型のロードマップを設計してください。

ゴール: ${goalTitle}
${goalDescription ? `詳細: ${goalDescription}` : ""}
${targetDate ? `期限: ${targetDate.toISOString().slice(0, 10)}` : ""}
${userContext ? `\n${userContext}\n` : ""}
${clarifyText}                                  // ヒアリング結果QA一覧

利用可能なレッスン:
${lessonList}                                   // - lessonId | コース > モジュール > レッスン | 要約 形式

ルール:
- マイルストーンは3〜6個、各マイルストーンに3〜6タスク
- ゴールに直接関連するレッスンを優先選択。lessonIdは必ず上記リストのIDから選ぶ
- 関連するレッスンがない領域は type="task" のカスタムタスクを作成
- 簡単→難しいの順、依存関係を考慮
- 各タスクのtitleは「動詞で始まる短文」(例: "MCPの基本概念を理解する")
- ユーザーのスキルレベル・制約・成功定義に合わせてタスクの粒度・難易度を調整
- ヒアリング結果から得られた具体情報をマイルストーン名やタスク説明に反映

create_roadmap ツールで返答してください。

※ 上記は学習レベル調整のための参考情報。今回のゴールに直接関係しない過去の文脈・職業・業種は勝手に推測しないこと。

Response 200:
{
  "goals": [
    {
      "id": "ckxxx",
      "title": "AIで動画編集を内製化する",
      "description": "...",
      "targetDate": "2026-08-31T00:00:00.000Z",
      "status": "active",
      "progressPct": 35,
      "totalTasks": 20,
      "completedTasks": 7,
      "createdAt": "...",
      "updatedAt": "..."
    }
  ]
}

Request:
{
  "goalTitle": "AIで動画編集を内製化する",
  "goalDescription": "外注を全社内化したい"
}

Response 200:
{
  "sections": [
    {
      "key": "current",
      "title": "現在地",
      "questions": [
        {
          "id": "current-1",
          "question": "このゴール領域での経験レベルは？",
          "suggestions": ["全くの初心者", "基本は知っている", "実務で触れている", "得意分野"]
        },
        ... 計3問
      ]
    },
    ... 4セクション計12問
  ]
}

Request:
{
  "title": "AIで動画編集を内製化する",
  "description": "...",
  "targetDate": "2026-08-31",
  "clarifications": [
    { "question": "経験レベルは？", "answer": "基本は知っている" },
    { "question": "週の学習時間は？", "answer": "5〜10時間" },
    ...
  ]
}

Response 201:
{
  "goal": {
    "id": "...",
    "title": "...",
    "milestones": [
      {
        "id": "...",
        "title": "土台を作る",
        "status": "active",
        "tasks": [
          { "id": "...", "type": "lesson", "title": "...", "lessonId": "...", "isCompleted": false },
          { "id": "...", "type": "task",   "title": "...", "isCompleted": false }
        ]
      },
      ...
    ]
  }
}

Response 400: バリデーションエラー（title欠落・長さ超過など）
Response 401: 認証失敗

Request:
{
  "clarifications": [ ... 任意で再ヒアリング結果 ... ]
}

Response 200: 6.3 と同じ構造

Request:
{
  "isCompleted": true
}

Response 200:
{
  "task": { "id": "...", "isCompleted": true, "completedAt": "..." },
  "milestoneStatus": "active" | "completed",     // マイルストーン再計算結果
  "goalStatus": "active" | "completed"            // ゴール再計算結果
}

async function syncCompletedLessonsToTasks(userId: string, goalId: string) {
  // 1. 該当ゴールのlessonId付きタスクを取得
  const tasks = await prisma.roadmapTask.findMany({
    where: {
      userId,
      lessonId: { not: null },
      milestone: { goalId },
    },
    select: { id: true, lessonId: true },
  });
  if (tasks.length === 0) return;

  // 2. それらのlessonIdの視聴完了状態を確認
  const lessonIds = Array.from(new Set(tasks.map((t) => t.lessonId!)));
  const completed = await prisma.lessonProgress.findMany({
    where: { userId, lessonId: { in: lessonIds }, isCompleted: true },
    select: { lessonId: true },
  });
  const completedSet = new Set(completed.map((p) => p.lessonId));

  // 3. 該当タスクを一括完了
  const taskIds = tasks.filter((t) => completedSet.has(t.lessonId!)).map((t) => t.id);
  if (taskIds.length === 0) return;
  await prisma.roadmapTask.updateMany({
    where: { id: { in: taskIds } },
    data: { isCompleted: true, completedAt: new Date() },
  });

  // 4. マイルストーンステータス再計算
  await recalculateMilestoneStatuses(goalId);
}

await prisma.memory.createMany({
  data: clarifications.map((c) => ({
    userId: auth.userId,
    type: "fact",
    content: `${c.question} → ${c.answer}`,
    confidence: 0.9,
    source: "roadmap_clarification",
    sourceId: goal.id,
  })),
});

interface AvailableLesson {
  id: string;
  title: string;
  description: string | null;
  summary: string | null;
  courseTitle: string;
  moduleTitle: string;
}

async function getAvailableLessons(userId: string): Promise {
  // 1. このユーザーがアクセス権を持つコースを取得（または全コース）
  // 2. 各コースの公開済みモジュール → 公開済みレッスンを順に展開
  // 3. ROADMAP_EXCLUDE_TITLE_PATTERNS に該当するレッスンは除外
  // 4. 配列で返す
}

// 除外パターン例（システム的に意味ないレッスンを排除）
const ROADMAP_EXCLUDE_TITLE_PATTERNS = [
  "バイブコーディング完全攻略",
  // クライアント側で必要に応じて追加
];

function fallbackResult(): GenerationResult {
  return {
    milestones: [
      {
        title: "スタート",
        description: "AI生成に失敗しました。手動でタスクを追加してください。",
        tasks: [],
      },
    ],
    model: "fallback",
  };
}

// goalsテーブル側で記録
generatedBy: result.model === "fallback" ? "manual" : "ai"
generationModel: result.model

const SECTION_FALLBACKS: ClarifyingSection[] = [
  {
    key: "current",
    title: "現在地",
    questions: [
      { id: "current-1", question: "このゴール領域での経験レベルは？",
        suggestions: ["全くの初心者", "基本は知っている", "実務で触れている", "得意分野"] },
      { id: "current-2", question: "今、何に詰まっていますか？",
        suggestions: ["何から始めるか不明", "技術選定で迷っている", "具体的な実装方法", "特になし"] },
      { id: "current-3", question: "関連する既存スキル・経験は？",
        suggestions: ["プログラミング経験あり", "デザイン経験あり", "マーケ経験あり", "特になし"] }
    ]
  },
  // goal / constraints / success セクションも同様に3問ずつ
  // → 完全版はオリジナル lib/roadmap-generator.ts の SECTION_FALLBACKS 参照
];

// components/video/R2VideoPlayer.tsx
interface R2VideoPlayerProps {
  videoUrl: string;
  initialTime?: number;
  onProgress?: (watchedSeconds: number, percentComplete: number) => void;
  onEnded?: () => void;
}

const progressIntervalRef = useRef<NodeJS.Timeout | null>(null);

useEffect(() => {
  // 5秒ごとに再生位置を上位に通知
  progressIntervalRef.current = setInterval(() => {
    if (!video) return;
    const percent = video.duration > 0
      ? (video.currentTime / video.duration) * 100
      : 0;
    onProgress?.(video.currentTime, percent);
  }, 5000);

  return () => {
    if (progressIntervalRef.current) clearInterval(progressIntervalRef.current);
  };
}, [video, onProgress]);

// app/(protected)/courses/[slug]/lessons/[lessonId]/page.tsx

const saveProgress = async (
  watchedSeconds: number,
  percentComplete: number,
  isCompleted: boolean
) => {
  try {
    await fetch(`/api/lessons/${lessonId}/progress`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        Authorization: `Bearer ${token}`,
      },
      body: JSON.stringify({ watchedSeconds, percentComplete, isCompleted }),
    });
  } catch (error) {
    console.error("Failed to save progress:", error);
  }
};

// 1) 視聴復帰: 前回の watchedSeconds から再開
if (lesson.progress?.watchedSeconds > 0 && !lesson.progress.isCompleted) {
  player.setCurrentTime(lesson.progress.watchedSeconds);
}

// 2) 定期保存: 30秒ごと（途中進捗、isCompleted=false）
progressIntervalRef.current = setInterval(async () => {
  await saveProgress(currentTime, percentComplete, false);
}, 30_000);

// 3) 動画終端 or 視聴率90%到達 → isCompleted=true 送信
const handleVideoEnded = async () => {
  await saveProgress(duration, 100, true);
  // ローカル状態も即座に completed に
  setLesson((l) => l && l.progress
    ? { ...l, progress: { ...l.progress, isCompleted: true } }
    : l
  );
};

// app/api/lessons/[id]/progress/route.ts
import { updateLessonProgress } from "@/lib/courses";
import { validateToken } from "@/lib/auth";

export async function POST(
  request: NextRequest,
  { params }: { params: Promise<{ id: string }> }
) {
  // 1. 認証
  const payload = await validateToken(request.headers.get("authorization"));
  if (!payload) return NextResponse.json({ error: "認証が必要です" }, { status: 401 });

  // 2. 入力バリデーション
  const { id } = await params;
  const { watchedSeconds, percentComplete, isCompleted } = await request.json();

  if (
    (watchedSeconds !== undefined && (typeof watchedSeconds !== "number" || watchedSeconds < 0)) ||
    (percentComplete !== undefined && (typeof percentComplete !== "number" || percentComplete < 0 || percentComplete > 100)) ||
    (isCompleted !== undefined && typeof isCompleted !== "boolean")
  ) {
    return NextResponse.json({ error: "無効なパラメータです" }, { status: 400 });
  }

  // 3. DB 更新（upsertでinsert/update自動判別）
  const progress = await updateLessonProgress(id, payload.userId, {
    watchedSeconds, percentComplete, isCompleted,
  });

  // 4. ★ レッスン完了時のみ、ロードマップタスクを連鎖完了
  let completedTaskIds: string[] = [];
  if (isCompleted === true) {
    try {
      const { completeTasksForLesson } = await import("@/lib/roadmap");
      completedTaskIds = await completeTasksForLesson(payload.userId, id);
    } catch (err) {
      console.error("[Roadmap sync error]", err);
      // ★ 失敗してもレッスン進捗の保存は成功扱い（疎結合）
    }
  }

  return NextResponse.json({ ...progress, completedTaskIds });
}

// lib/courses.ts 想定実装
export async function updateLessonProgress(
  lessonId: string,
  userId: string,
  input: {
    watchedSeconds?: number;
    percentComplete?: number;
    isCompleted?: boolean;
  }
) {
  return prisma.lessonProgress.upsert({
    where: { userId_lessonId: { userId, lessonId } },
    create: {
      userId,
      lessonId,
      watchedSeconds:  input.watchedSeconds  ?? 0,
      percentComplete: input.percentComplete ?? 0,
      isCompleted:     input.isCompleted     ?? false,
      status: input.isCompleted ? "completed" :
              input.percentComplete && input.percentComplete > 0 ? "in_progress" : "not_started",
      lastAccessedAt:  new Date(),
      completedAt:     input.isCompleted ? new Date() : null,
    },
    update: {
      // 退行防止: より大きい値だけ採用
      watchedSeconds:  input.watchedSeconds  !== undefined ? { set: input.watchedSeconds  } : undefined,
      percentComplete: input.percentComplete !== undefined ? { set: input.percentComplete } : undefined,
      isCompleted:     input.isCompleted     !== undefined ? { set: input.isCompleted     } : undefined,
      status: input.isCompleted === true ? "completed" : undefined,
      lastAccessedAt:  new Date(),
      completedAt:     input.isCompleted === true ? new Date() : undefined,
    },
  });
}

// lib/roadmap.ts
export async function completeTasksForLesson(
  userId: string,
  lessonId: string
): Promise<string[]> {
  // 1. このユーザーの該当 lessonId に紐づく未完了 RoadmapTask を取得
  const tasks = await prisma.roadmapTask.findMany({
    where: { userId, lessonId, isCompleted: false },
    select: { id: true, milestoneId: true, milestone: { select: { goalId: true } } },
  });
  if (tasks.length === 0) return [];

  const taskIds = tasks.map((t) => t.id);

  // 2. 全タスクを isCompleted=true に
  await prisma.roadmapTask.updateMany({
    where: { id: { in: taskIds } },
    data: { isCompleted: true, completedAt: new Date() },
  });

  // 3. 影響を受けたゴールで milestone ステータス再計算
  const affectedGoalIds = Array.from(new Set(tasks.map((t) => t.milestone.goalId)));
  for (const goalId of affectedGoalIds) {
    await recalculateMilestoneStatuses(goalId);
  }

  return taskIds;
}

// recalculateMilestoneStatuses のロジック概要:
//   1. ゴール配下のmilestoneを sortOrder 順に取得（tasks含む）
//   2. 各milestoneで全タスク isCompleted=true なら status=completed
//   3. 最初の未完了milestoneを active に、それより後を locked に
//   4. 全milestoneがcompletedなら goal.status=completed, completedAt=now()

// app/api/admin/progress/route.ts
import { validateAdminRequest } from "@/lib/admin-auth";

export async function GET(request: NextRequest) {
  // 1. 管理者認証
  const authResult = await validateAdminRequest(request);
  if (!authResult.success) {
    return NextResponse.json({ error: authResult.error }, { status: 401 });
  }

  // 2. クエリパラメータ
  const { searchParams } = new URL(request.url);
  const search = searchParams.get("search") || "";
  const cohort = searchParams.get("cohort");

  const userWhere: Record<string, unknown> = {};
  if (search) {
    userWhere.OR = [
      { email: { contains: search, mode: "insensitive" } },
      { name:  { contains: search, mode: "insensitive" } },
    ];
  }
  if (cohort) userWhere.cohort = cohort === "null" ? null : parseInt(cohort, 10);

  // 3. 並列取得（users / lessons / progressData）
  const [users, lessons, progressData] = await Promise.all([
    prisma.user.findMany({
      where: { ...userWhere, courseAccess: { some: {} } },
      select: { id: true, email: true, name: true, cohort: true,
                lastActiveAt: true, lineFriendId: true },
      orderBy: [{ cohort: "asc" }, { createdAt: "desc" }],
    }),
    prisma.lesson.findMany({
      where: {
        isPublished: true,
        lessonType: "video",
        module: { isPublished: true, course: { isPublished: true } },
      },
      select: {
        id: true, title: true, sortOrder: true,
        module: { select: {
          id: true, title: true, sortOrder: true,
          course: { select: { slug: true, title: true } },
        }},
      },
      orderBy: [{ module: { sortOrder: "asc" } }, { sortOrder: "asc" }],
    }),
    prisma.lessonProgress.findMany({
      select: { userId: true, lessonId: true, percentComplete: true,
                isCompleted: true, watchedSeconds: true, lastAccessedAt: true },
    }),
  ]);

  // 4. 統計計算
  const stats = {
    totalUsers:     users.length,
    totalVideos:    lessons.length,
    completedCount: progressData.filter((p) => p.isCompleted).length,
    averageCompletion: progressData.length > 0
      ? progressData.reduce((s, p) => s + p.percentComplete, 0) / progressData.length
      : 0,
  };

  return NextResponse.json({ users, videos: lessons, progress: progressData, stats });
}

// app/(admin)/progress/page.tsx 想定実装
const { users, videos, progress, stats } = data;

// 1. 高速ルックアップ用のMap化
const progressMap = new Map<string, Map<string, ProgressEntry>>();
for (const p of progress) {
  if (!progressMap.has(p.userId)) progressMap.set(p.userId, new Map());
  progressMap.get(p.userId)!.set(p.lessonId, p);
}

// 2. マトリクス描画
<table>
  <thead>
    <tr>
      <th>ユーザー</th>
      {videos.map((v) => <th key={v.id}>{v.title}</th>)}
    </tr>
  </thead>
  <tbody>
    {users.map((u) => (
      <tr key={u.id}>
        <td>{u.name} ({u.email})</td>
        {videos.map((v) => {
          const p = progressMap.get(u.id)?.get(v.id);
          return (
            <td key={v.id}>
              {p?.isCompleted    ? "✅ 100%" :
               p?.percentComplete ? `🔵 ${Math.round(p.percentComplete)}%` :
               "⬜ 0%"}
            </td>
          );
        })}
      </tr>
    ))}
  </tbody>
</table>