# AI契約書チェックの核心ロジック（簡略版）
contract_review_system = {
    "input": "契約書PDF/テキスト",
    "processing_pipeline": [
        {
            "step": "文書構造化",
            "action": "OCR + セクション分割",
            "tool": "pdf-parse + GPT-4o（画像認識）"
        },
        {
            "step": "リスク分析",
            "action": "各条項のリスクスコアリング",
            "tool": "Claude（法務プロンプト）",
            "prompt_template": """
あなたは日本の契約法に精通した法務AIアシスタントです。
以下の契約書条項を分析し、リスクを評価してください。
 
【条項】
{clause_text}
 
【評価基準】
1. 一方的に不利な条項はないか
2. 損害賠償の上限は適切か
3. 解約条件は合理的か
4. 知的財産権の帰属は明確か
5. 秘密保持義務の範囲は適切か
 
JSON形式で回答してください:
{
  "risk_level": "high/medium/low",
  "issues": ["問題点のリスト"],
  "suggestions": ["改善提案のリスト"],
  "explanation": "平易な日本語での解説"
}
"""
        },
        {
            "step": "レポート生成",
            "action": "リスクサマリー + 推奨アクション",
            "output": "PDF/HTML レポート"
        }
    ],
    "pricing_logic": "1契約書あたりの価値: 弁護士依頼 ¥30,000-100,000",
    "competitive_advantage": "10秒で結果、弁護士の1/10の費用"
}

# アイデア評価スコアカード
idea_scorecard = {
    "criteria": [
        {
            "name": "課題の深刻度",
            "question": "これがないと何時間/何円の損失?",
            "weight": 3,
            "score_guide": {
                5: "月10万円以上の損失 or 月10時間以上の浪費",
                3: "月5万円 or 月5時間",
                1: "あると便利だが、なくても困らない"
            }
        },
        {
            "name": "市場サイズ",
            "question": "この課題を持つ人は何人?",
            "weight": 2,
            "score_guide": {
                5: "100万人以上（グローバル）",
                3: "10万-100万人",
                1: "1万人未満"
            }
        },
        {
            "name": "AI適合度",
            "question": "AIで既存の10倍以上改善できる?",
            "weight": 3,
            "score_guide": {
                5: "AIなしでは不可能な体験を提供",
                3: "AIで大幅に効率化",
                1: "AIを使う意味が薄い"
            }
        },
        {
            "name": "1人開発可能性",
            "question": "4週間以内にMVPを作れる?",
            "weight": 2,
            "score_guide": {
                5: "2週間で動くプロトタイプ可能",
                3: "4週間で可能",
                1: "3ヶ月以上必要"
            }
        },
        {
            "name": "収益化容易性",
            "question": "ユーザーは月¥3,000-¥10,000払う?",
            "weight": 3,
            "score_guide": {
                5: "既にお金を払っている代替手段がある",
                3: "払う意思を確認済み",
                1: "無料が当然の領域"
            }
        }
    ],
    "threshold": 50,  # 65点満点中50点以上で実行
    "max_score": 65
}

# 検証ステップの実装
class IdeaValidator:
    """2週間でアイデアを検証するフレームワーク"""
 
    def __init__(self, idea_name: str, target_audience: str):
        self.idea_name = idea_name
        self.target_audience = target_audience
        self.validation_results = {}
 
    def week1_demand_validation(self):
        """Week 1: 需要の検証"""
        steps = {
            "day_1_2": {
                "task": "競合調査",
                "actions": [
                    "Google検索で類似サービスを10個リストアップ",
                    "各サービスの価格・機能・レビューを記録",
                    "SimilarWebでトラフィック量を調査",
                    "App StoreレビューやG2で不満点を収集"
                ],
                "output": "competitive_analysis.md"
            },
            "day_3_4": {
                "task": "ターゲットインタビュー",
                "actions": [
                    "Twitter/XでDMを20人に送る",
                    "Reddit関連サブレで質問投稿",
                    "知人・友人ネットワークで5人以上と通話",
                    "「この問題にいくら払いますか？」を必ず聞く"
                ],
                "output": "interview_notes.md"
            },
            "day_5_7": {
                "task": "ランディングページテスト",
                "actions": [
                    "Carrd.co で1ページLP作成（30分）",
                    "「近日公開」+ メール登録フォーム",
                    "Twitter広告 ¥5,000 でLP誘導テスト",
                    "メール登録率 10%以上なら需要あり"
                ],
                "output": "lp_conversion_data.csv"
            }
        }
        return steps
 
    def week2_technical_validation(self):
        """Week 2: 技術的実現可能性の検証"""
        steps = {
            "day_8_9": {
                "task": "AI精度テスト",
                "actions": [
                    "Claude/GPT-4 APIで10件のサンプル処理",
                    "出力品質を5段階評価",
                    "プロンプトの最適化（3回以上イテレーション）",
                    "合格基準: 80%以上が4以上の評価"
                ]
            },
            "day_10_11": {
                "task": "コスト試算",
                "actions": [
                    "API呼び出し1回あたりのトークン数を計測",
                    "月200ユーザー × 平均利用回数 でAPI費用算出",
                    "粗利率70%以上を確認",
                    "スケール時のコスト変動もシミュレーション"
                ]
            },
            "day_12_14": {
                "task": "プロトタイプ作成",
                "actions": [
                    "Streamlit/Gradio で動くデモ作成",
                    "Week 1のインタビュー対象者に見せる",
                    "「お金を払いますか？」の最終確認",
                    "Go/No-Go 判定"
                ]
            }
        }
        return steps
 
    def go_nogo_decision(self, metrics: dict) -> str:
        """Go/No-Go判定"""
        criteria = {
            "lp_conversion_rate": (metrics.get("lp_signups", 0) /
                                   max(metrics.get("lp_visitors", 1), 1)),
            "interview_willingness": metrics.get("willing_to_pay_count", 0) /
                                     max(metrics.get("total_interviews", 1), 1),
            "ai_quality_score": metrics.get("avg_quality_score", 0),
            "gross_margin": metrics.get("estimated_gross_margin", 0),
        }
 
        go_conditions = [
            criteria["lp_conversion_rate"] >= 0.10,     # LP転換率10%以上
            criteria["interview_willingness"] >= 0.50,    # 50%以上が支払い意思あり
            criteria["ai_quality_score"] >= 4.0,          # AI品質4.0/5.0以上
            criteria["gross_margin"] >= 0.70,             # 粗利率70%以上
        ]
 
        passed = sum(go_conditions)
        if passed >= 4:
            return "GO: 全条件クリア。MVP開発に進む"
        elif passed >= 3:
            return "CONDITIONAL GO: 弱い条件を改善しつつMVP開発"
        else:
            return "NO-GO: アイデアを見直すか別のアイデアへ"

# 個人開発者向け最速MVPスタック
solo_dev_stack = {
    "week_1": {
        "tasks": [
            "Next.js プロジェクト初期化",
            "Supabase セットアップ（DB + Auth）",
            "Stripe 接続（テストモード）",
            "LP作成（1ページ）"
        ],
        "tools": "Next.js 14 + shadcn/ui + Supabase + Stripe"
    },
    "week_2": {
        "tasks": [
            "コアAI機能の実装（1機能のみ）",
            "OpenAI/Claude API 統合",
            "入力フォーム → AI処理 → 結果表示",
            "エラーハンドリング"
        ],
        "tools": "Vercel AI SDK + OpenAI API"
    },
    "week_3": {
        "tasks": [
            "使用量制限（無料10回/月）",
            "Stripe Checkout 統合",
            "ユーザーダッシュボード",
            "基本的な使用量トラッキング"
        ],
        "tools": "Stripe + Supabase Edge Functions"
    },
    "week_4": {
        "tasks": [
            "Vercel デプロイ",
            "独自ドメイン設定",
            "基本SEO（タイトル、meta、OGP）",
            "Product Hunt 準備",
            "テストと修正"
        ],
        "tools": "Vercel + Google Search Console"
    }
}

// プロジェクト初期化スクリプト
// npx create-next-app@latest my-ai-saas --typescript --tailwind --app
 
// src/app/layout.tsx - 基本レイアウト
import { Inter } from 'next/font/google'
import { Toaster } from '@/components/ui/toaster'
import { AuthProvider } from '@/components/auth-provider'
 
const inter = Inter({ subsets: ['latin'] })
 
export const metadata = {
  title: 'AI SaaS - あなたの[課題]を10倍速く解決',
  description: 'AIを使って[ターゲット]の[課題]を自動化するサービス',
  openGraph: {
    title: 'AI SaaS - あなたの[課題]を10倍速く解決',
    description: 'AIを使って[ターゲット]の[課題]を自動化するサービス',
    images: ['/og-image.png'],
  },
}
 
export default function RootLayout({
  children,
}: {
  children: React.ReactNode
}) {
  return (
    <html lang="ja">
      <body className={inter.className}>
        <AuthProvider>
          {children}
          <Toaster />
        </AuthProvider>
      </body>
    </html>
  )
}

// src/lib/supabase/client.ts - Supabaseクライアント設定
import { createBrowserClient } from '@supabase/ssr'
 
export function createClient() {
  return createBrowserClient(
    process.env.NEXT_PUBLIC_SUPABASE_URL!,
    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!
  )
}
 
// src/lib/supabase/server.ts - サーバーサイドクライアント
import { createServerClient } from '@supabase/ssr'
import { cookies } from 'next/headers'
 
export function createServerSupabaseClient() {
  const cookieStore = cookies()
  return createServerClient(
    process.env.NEXT_PUBLIC_SUPABASE_URL!,
    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
    {
      cookies: {
        get(name: string) {
          return cookieStore.get(name)?.value
        },
        set(name: string, value: string, options: any) {
          cookieStore.set({ name, value, ...options })
        },
        remove(name: string, options: any) {
          cookieStore.set({ name, value: '', ...options })
        },
      },
    }
  )
}

// src/app/api/generate/route.ts - AI生成APIルート
import { NextRequest, NextResponse } from 'next/server'
import Anthropic from '@anthropic-ai/sdk'
import { createServerSupabaseClient } from '@/lib/supabase/server'
 
const anthropic = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY!,
})
 
// レート制限用のシンプルなインメモリキャッシュ
const rateLimitMap = new Map<string, { count: number; resetAt: number }>()
 
function checkRateLimit(userId: string, maxRequests: number = 10): boolean {
  const now = Date.now()
  const userLimit = rateLimitMap.get(userId)
 
  if (!userLimit || now > userLimit.resetAt) {
    rateLimitMap.set(userId, { count: 1, resetAt: now + 60000 }) // 1分間
    return true
  }
 
  if (userLimit.count >= maxRequests) {
    return false
  }
 
  userLimit.count++
  return true
}
 
export async function POST(request: NextRequest) {
  try {
    const supabase = createServerSupabaseClient()
 
    // 認証チェック
    const { data: { user }, error: authError } = await supabase.auth.getUser()
    if (authError || !user) {
      return NextResponse.json(
        { error: 'Unauthorized' },
        { status: 401 }
      )
    }
 
    // レート制限チェック
    if (!checkRateLimit(user.id)) {
      return NextResponse.json(
        { error: 'Rate limit exceeded. Please wait a moment.' },
        { status: 429 }
      )
    }
 
    // 使用量チェック
    const currentMonth = new Date().toISOString().slice(0, 7) // "2026-02"
    const { data: usage } = await supabase
      .from('usage')
      .select('count')
      .eq('user_id', user.id)
      .eq('month', currentMonth)
      .single()
 
    const currentCount = usage?.count || 0
 
    // プラン別の制限
    const { data: profile } = await supabase
      .from('profiles')
      .select('plan')
      .eq('id', user.id)
      .single()
 
    const limits: Record<string, number> = {
      free: 10,
      pro: 500,
      premium: 2000,
    }
 
    const userLimit = limits[profile?.plan || 'free']
 
    if (currentCount >= userLimit) {
      return NextResponse.json({
        error: 'Usage limit reached',
        upgrade_url: '/pricing',
        current: currentCount,
        limit: userLimit,
      }, { status: 403 })
    }
 
    // リクエストボディの取得
    const { input, options } = await request.json()
 
    if (!input || typeof input !== 'string' || input.length > 10000) {
      return NextResponse.json(
        { error: 'Invalid input' },
        { status: 400 }
      )
    }
 
    // AI生成
    const message = await anthropic.messages.create({
      model: 'claude-sonnet-4-20250514',
      max_tokens: 2048,
      messages: [
        {
          role: 'user',
          content: buildPrompt(input, options),
        },
      ],
    })
 
    const result = message.content[0].type === 'text'
      ? message.content[0].text
      : ''
 
    const tokensUsed = message.usage.input_tokens + message.usage.output_tokens
 
    // 使用量の更新
    await supabase.from('usage').upsert({
      user_id: user.id,
      month: currentMonth,
      count: currentCount + 1,
      tokens_total: (usage as any)?.tokens_total
        ? (usage as any).tokens_total + tokensUsed
        : tokensUsed,
    })
 
    // 履歴の保存
    await supabase.from('history').insert({
      user_id: user.id,
      input: input.slice(0, 1000), // 保存は先頭1000文字まで
      output: result.slice(0, 2000),
      tokens_used: tokensUsed,
      model: 'claude-sonnet-4-20250514',
    })
 
    return NextResponse.json({
      result,
      remaining: userLimit - currentCount - 1,
      tokens_used: tokensUsed,
    })
 
  } catch (error: any) {
    console.error('Generate error:', error)
 
    if (error.status === 429) {
      return NextResponse.json(
        { error: 'AI API rate limit. Please retry in a few seconds.' },
        { status: 429 }
      )
    }
 
    return NextResponse.json(
      { error: 'Internal server error' },
      { status: 500 }
    )
  }
}
 
function buildPrompt(input: string, options?: Record<string, any>): string {
  // プロダクト固有のプロンプトテンプレート
  const systemContext = `あなたは[専門分野]のプロフェッショナルです。
ユーザーの入力を分析し、具体的で実用的なアドバイスを提供してください。
 
ルール:
- 日本語で回答
- 具体的な数値や例を含める
- 実行可能なアクションアイテムを提示
- 専門用語は平易な説明を添える`
 
  return `${systemContext}\n\n---\n\nユーザー入力:\n${input}`
}

# PMFスコア測定システム
from dataclasses import dataclass
from datetime import datetime, timedelta
from typing import Optional
 
 
@dataclass
class PMFMetrics:
    """PMF達成度を測定するメトリクス"""
 
    # Sean Ellis テスト: 「このプロダクトが使えなくなったらどう感じますか？」
    very_disappointed_pct: float  # 「とても困る」と答えた割合
 
    # エンゲージメント指標
    dau_mau_ratio: float         # DAU/MAU比率
    weekly_active_rate: float    # 週次アクティブ率
 
    # リテンション指標
    day7_retention: float        # 7日後リテンション
    day30_retention: float       # 30日後リテンション
    monthly_churn_rate: float    # 月次解約率
 
    # 成長指標
    organic_signup_rate: float   # オーガニック登録の割合
    nps_score: float             # Net Promoter Score
 
    def pmf_score(self) -> float:
        """PMFスコアを0-100で計算"""
        scores = {
            "sean_ellis": min(self.very_disappointed_pct / 0.40 * 30, 30),
            "engagement": min(self.dau_mau_ratio / 0.20 * 20, 20),
            "retention": min(self.day30_retention / 0.30 * 25, 25),
            "growth": min(self.organic_signup_rate / 0.60 * 15, 15),
            "nps": min(max(self.nps_score / 50 * 10, 0), 10),
        }
        return sum(scores.values())
 
    def pmf_status(self) -> str:
        """PMFステータスの判定"""
        score = self.pmf_score()
        if score >= 80:
            return "Strong PMF - スケール段階に進める"
        elif score >= 60:
            return "Early PMF - 改善しつつ慎重にスケール"
        elif score >= 40:
            return "Pre-PMF - 機能改善に集中"
        else:
            return "No PMF - ピボットを検討"
 
    def improvement_priorities(self) -> list[str]:
        """改善の優先順位を返す"""
        priorities = []
        if self.very_disappointed_pct < 0.40:
            priorities.append("Sean Ellisスコアが低い: コア価値の明確化が必要")
        if self.day30_retention < 0.20:
            priorities.append("30日リテンションが低い: オンボーディング改善")
        if self.monthly_churn_rate > 0.10:
            priorities.append("チャーン率が高い: 解約理由の調査と対策")
        if self.organic_signup_rate < 0.30:
            priorities.append("オーガニック流入が低い: SEOとバイラル施策")
        return priorities
 
 
# 使用例
metrics = PMFMetrics(
    very_disappointed_pct=0.45,
    dau_mau_ratio=0.15,
    weekly_active_rate=0.60,
    day7_retention=0.35,
    day30_retention=0.22,
    monthly_churn_rate=0.08,
    organic_signup_rate=0.40,
    nps_score=35.0,
)
 
print(f"PMFスコア: {metrics.pmf_score():.1f}/100")
print(f"ステータス: {metrics.pmf_status()}")
print(f"改善優先: {metrics.improvement_priorities()}")

# スケール戦略の実装
scaling_strategy = {
    "revenue_levers": {
        "increase_users": {
            "current": 50,
            "target": 200,
            "tactics": [
                "SEOブログ: 週2記事で月間1万PV → 月50登録",
                "紹介プログラム: 既存ユーザーの20%が1人紹介",
                "Twitter/X: フォロワー5,000人 → 月30登録",
                "Product Hunt再ローンチ: 半年後にv2.0で",
            ]
        },
        "increase_arpu": {
            "current": 5000,
            "target": 6000,
            "tactics": [
                "上位プラン追加: ¥9,800/月のPremiumプラン",
                "年間プラン割引: 月額の80%で年間契約推進",
                "アドオン機能: API アクセス ¥3,000/月",
                "利用量ベース課金の追加: 基本枠超過分",
            ]
        },
        "reduce_churn": {
            "current": 0.08,
            "target": 0.04,
            "tactics": [
                "解約前アンケート + 特別オファー",
                "利用減少ユーザーへの自動リエンゲージメント",
                "機能アップデートの定期告知",
                "ユーザーコミュニティの構築",
            ]
        }
    },
    "100m_scenarios": [
        {"users": 200, "arpu": 5000, "mrr": 1000000},
        {"users": 130, "arpu": 7700, "mrr": 1001000},
        {"users": 100, "arpu": 10000, "mrr": 1000000},
    ]
}

# FastAPI での最小AI SaaS バックエンド
from fastapi import FastAPI, Depends, HTTPException
from fastapi.middleware.cors import CORSMiddleware
import anthropic
import stripe
from supabase import create_client
 
app = FastAPI()
 
# 環境変数
ANTHROPIC_KEY = os.getenv("ANTHROPIC_API_KEY")
STRIPE_KEY = os.getenv("STRIPE_SECRET_KEY")
SUPABASE_URL = os.getenv("SUPABASE_URL")
SUPABASE_KEY = os.getenv("SUPABASE_KEY")
 
# クライアント初期化
ai = anthropic.Anthropic(api_key=ANTHROPIC_KEY)
stripe.api_key = STRIPE_KEY
db = create_client(SUPABASE_URL, SUPABASE_KEY)
 
@app.post("/api/generate")
async def generate(request: dict, user=Depends(auth)):
    """コアAI機能"""
    # 1. 使用量チェック
    usage = db.table("usage").select("count") \
        .eq("user_id", user.id) \
        .eq("month", current_month()).execute()
 
    current = usage.data[0]["count"] if usage.data else 0
    limit = 10 if user.plan == "free" else 1000
 
    if current >= limit:
        raise HTTPException(
            403,
            detail={"error": "limit_reached", "upgrade_url": "/pricing"}
        )
 
    # 2. AI生成
    response = ai.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        messages=[{
            "role": "user",
            "content": build_prompt(request["input"], user.preferences)
        }]
    )
 
    result = response.content[0].text
 
    # 3. 使用量記録
    db.table("usage").upsert({
        "user_id": user.id,
        "month": current_month(),
        "count": current + 1
    }).execute()
 
    # 4. 履歴保存
    db.table("history").insert({
        "user_id": user.id,
        "input": request["input"],
        "output": result,
        "tokens": response.usage.input_tokens + response.usage.output_tokens
    }).execute()
 
    return {"result": result, "remaining": limit - current - 1}

-- Supabase用 テーブル定義
-- 個人AI SaaS に必要な最小限のスキーマ
 
-- ユーザープロフィール
CREATE TABLE profiles (
    id UUID REFERENCES auth.users(id) PRIMARY KEY,
    email TEXT NOT NULL,
    plan TEXT DEFAULT 'free' CHECK (plan IN ('free', 'pro', 'premium')),
    stripe_customer_id TEXT,
    stripe_subscription_id TEXT,
    created_at TIMESTAMPTZ DEFAULT NOW(),
    updated_at TIMESTAMPTZ DEFAULT NOW()
);
 
-- 使用量トラッキング
CREATE TABLE usage (
    id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
    user_id UUID REFERENCES profiles(id) NOT NULL,
    month TEXT NOT NULL,  -- '2026-02' 形式
    count INTEGER DEFAULT 0,
    tokens_total BIGINT DEFAULT 0,
    api_cost_cents INTEGER DEFAULT 0,  -- APIコスト追跡（セント単位）
    created_at TIMESTAMPTZ DEFAULT NOW(),
    updated_at TIMESTAMPTZ DEFAULT NOW(),
    UNIQUE(user_id, month)
);
 
-- 生成履歴
CREATE TABLE history (
    id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
    user_id UUID REFERENCES profiles(id) NOT NULL,
    input TEXT NOT NULL,
    output TEXT NOT NULL,
    tokens_used INTEGER DEFAULT 0,
    model TEXT NOT NULL,
    processing_time_ms INTEGER,
    feedback_score INTEGER CHECK (feedback_score BETWEEN 1 AND 5),
    created_at TIMESTAMPTZ DEFAULT NOW()
);
 
-- フィードバック（PMF測定用）
CREATE TABLE feedback (
    id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
    user_id UUID REFERENCES profiles(id) NOT NULL,
    type TEXT CHECK (type IN ('nps', 'sean_ellis', 'feature_request', 'bug_report')),
    score INTEGER,
    comment TEXT,
    created_at TIMESTAMPTZ DEFAULT NOW()
);
 
-- Row Level Security
ALTER TABLE profiles ENABLE ROW LEVEL SECURITY;
ALTER TABLE usage ENABLE ROW LEVEL SECURITY;
ALTER TABLE history ENABLE ROW LEVEL SECURITY;
ALTER TABLE feedback ENABLE ROW LEVEL SECURITY;
 
CREATE POLICY "Users can read own profile"
    ON profiles FOR SELECT USING (auth.uid() = id);
 
CREATE POLICY "Users can read own usage"
    ON usage FOR SELECT USING (auth.uid() = user_id);
 
CREATE POLICY "Users can read own history"
    ON history FOR SELECT USING (auth.uid() = user_id);
 
-- インデックス
CREATE INDEX idx_usage_user_month ON usage(user_id, month);
CREATE INDEX idx_history_user_created ON history(user_id, created_at DESC);
CREATE INDEX idx_feedback_type ON feedback(type, created_at DESC);

// src/app/api/webhooks/stripe/route.ts
import { NextRequest, NextResponse } from 'next/server'
import Stripe from 'stripe'
import { createClient } from '@supabase/supabase-js'
 
const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!)
const supabase = createClient(
  process.env.SUPABASE_URL!,
  process.env.SUPABASE_SERVICE_ROLE_KEY!  // Webhook はサービスロールキー使用
)
 
export async function POST(request: NextRequest) {
  const body = await request.text()
  const signature = request.headers.get('stripe-signature')!
 
  let event: Stripe.Event
  try {
    event = stripe.webhooks.constructEvent(
      body,
      signature,
      process.env.STRIPE_WEBHOOK_SECRET!
    )
  } catch (err) {
    console.error('Webhook signature verification failed:', err)
    return NextResponse.json({ error: 'Invalid signature' }, { status: 400 })
  }
 
  switch (event.type) {
    case 'checkout.session.completed': {
      const session = event.data.object as Stripe.Checkout.Session
      await handleCheckoutCompleted(session)
      break
    }
 
    case 'customer.subscription.updated': {
      const subscription = event.data.object as Stripe.Subscription
      await handleSubscriptionUpdated(subscription)
      break
    }
 
    case 'customer.subscription.deleted': {
      const subscription = event.data.object as Stripe.Subscription
      await handleSubscriptionCanceled(subscription)
      break
    }
 
    case 'invoice.payment_failed': {
      const invoice = event.data.object as Stripe.Invoice
      await handlePaymentFailed(invoice)
      break
    }
  }
 
  return NextResponse.json({ received: true })
}
 
async function handleCheckoutCompleted(session: Stripe.Checkout.Session) {
  const userId = session.metadata?.user_id
  if (!userId) return
 
  await supabase
    .from('profiles')
    .update({
      plan: 'pro',
      stripe_customer_id: session.customer as string,
      stripe_subscription_id: session.subscription as string,
      updated_at: new Date().toISOString(),
    })
    .eq('id', userId)
 
  console.log(`User ${userId} upgraded to pro`)
}
 
async function handleSubscriptionUpdated(subscription: Stripe.Subscription) {
  const plan = subscription.status === 'active' ? 'pro' : 'free'
 
  await supabase
    .from('profiles')
    .update({ plan, updated_at: new Date().toISOString() })
    .eq('stripe_subscription_id', subscription.id)
}
 
async function handleSubscriptionCanceled(subscription: Stripe.Subscription) {
  await supabase
    .from('profiles')
    .update({
      plan: 'free',
      stripe_subscription_id: null,
      updated_at: new Date().toISOString(),
    })
    .eq('stripe_subscription_id', subscription.id)
 
  console.log(`Subscription ${subscription.id} canceled`)
}
 
async function handlePaymentFailed(invoice: Stripe.Invoice) {
  // 支払い失敗の通知（Resend等でメール送信）
  console.warn(`Payment failed for invoice ${invoice.id}`)
}

# APIコスト削減のための実装パターン
 
import hashlib
import json
from functools import lru_cache
from datetime import datetime, timedelta
 
 
class APICostOptimizer:
    """AI APIのコストを最適化するユーティリティ"""
 
    def __init__(self, redis_client=None):
        self.redis = redis_client
        self.cost_per_1k_input = 0.003   # Claude Sonnet入力: $3/MTok
        self.cost_per_1k_output = 0.015  # Claude Sonnet出力: $15/MTok
 
    def cache_key(self, prompt: str, model: str) -> str:
        """キャッシュキーの生成"""
        content = f"{model}:{prompt}"
        return f"ai_cache:{hashlib.sha256(content.encode()).hexdigest()}"
 
    async def generate_with_cache(
        self,
        client,
        prompt: str,
        model: str = "claude-sonnet-4-20250514",
        cache_ttl: int = 3600
    ):
        """キャッシュ付きAI生成"""
        # 1. キャッシュチェック
        if self.redis:
            key = self.cache_key(prompt, model)
            cached = await self.redis.get(key)
            if cached:
                return json.loads(cached), {"cached": True, "cost": 0}
 
        # 2. API呼び出し
        response = client.messages.create(
            model=model,
            max_tokens=1024,
            messages=[{"role": "user", "content": prompt}]
        )
 
        result = response.content[0].text
        cost = self._calculate_cost(response.usage)
 
        # 3. キャッシュ保存
        if self.redis:
            await self.redis.setex(
                key,
                cache_ttl,
                json.dumps(result)
            )
 
        return result, {"cached": False, "cost": cost}
 
    def _calculate_cost(self, usage) -> float:
        """APIコストの計算（USD）"""
        input_cost = (usage.input_tokens / 1000) * self.cost_per_1k_input
        output_cost = (usage.output_tokens / 1000) * self.cost_per_1k_output
        return round(input_cost + output_cost, 6)
 
    def select_optimal_model(self, task_complexity: str) -> str:
        """タスク複雑度に応じた最適モデル選択"""
        model_map = {
            "simple": "claude-haiku-4-20250514",      # 分類、抽出 → 安い
            "moderate": "claude-sonnet-4-20250514",   # 一般的な生成
            "complex": "claude-sonnet-4-20250514",    # 高品質な分析
        }
        return model_map.get(task_complexity, "claude-sonnet-4-20250514")
 
    def estimate_monthly_cost(
        self,
        users: int,
        avg_requests_per_user: int,
        avg_input_tokens: int = 500,
        avg_output_tokens: int = 800
    ) -> dict:
        """月間APIコストの見積もり"""
        total_requests = users * avg_requests_per_user
        total_input_tokens = total_requests * avg_input_tokens
        total_output_tokens = total_requests * avg_output_tokens
 
        input_cost = (total_input_tokens / 1_000_000) * 3.0    # $3/MTok
        output_cost = (total_output_tokens / 1_000_000) * 15.0  # $15/MTok
        total_usd = input_cost + output_cost
        total_jpy = total_usd * 150  # 為替レート仮定
 
        return {
            "total_requests": total_requests,
            "total_input_tokens": total_input_tokens,
            "total_output_tokens": total_output_tokens,
            "cost_usd": round(total_usd, 2),
            "cost_jpy": round(total_jpy, 0),
            "cost_per_request_jpy": round(total_jpy / total_requests, 1),
        }
 
 
# コスト見積もり例
optimizer = APICostOptimizer()
estimate = optimizer.estimate_monthly_cost(
    users=200,
    avg_requests_per_user=30,  # 月30回利用
    avg_input_tokens=500,
    avg_output_tokens=800
)
# → { "cost_jpy": 約81,000, "cost_per_request_jpy": 13.5 }

build_in_public = {
    "daily_tweets": [
        "開発進捗（スクショ付き）",
        "ユーザー数/MRRの公開",
        "学んだ教訓",
        "技術的な挑戦と解決策"
    ],
    "weekly_posts": [
        "週次レポート（数字付き）",
        "機能リリースの告知",
        "ユーザーフィードバックの共有"
    ],
    "milestone_posts": [
        "最初の有料ユーザー獲得",
        "MRR $1,000 達成",
        "Product Hunt ローンチ",
        "月収100万円達成"
    ],
    "effect": "フォロワー → 初期ユーザー → バイラル拡散",
    "example_format": (
        "Day 47 of building [ProductName]:\n\n"
        "This week:\n"
        "- Added feature X\n"
        "- 23 new signups\n"
        "- MRR: $2,400 (+15%)\n\n"
        "Biggest learning: [insight]\n\n"
        "#buildinpublic #indiehackers"
    )
}

# SEOコンテンツ戦略
seo_content_strategy = {
    "keyword_research": {
        "tools": ["Ubersuggest（無料枠）", "Google Keyword Planner", "AnswerThePublic"],
        "target_keywords": {
            "transactional": [
                "[課題] ツール",
                "[課題] 自動化",
                "[課題] 効率化 方法",
            ],
            "informational": [
                "[課題] とは",
                "[課題] やり方",
                "[課題] コツ",
                "[課題] テンプレート",
            ],
            "comparison": [
                "[競合A] vs [競合B]",
                "[競合名] 代替",
                "[競合名] 料金",
            ]
        },
        "selection_criteria": {
            "monthly_search_volume": "100-5000（ニッチだが需要あり）",
            "keyword_difficulty": "30以下（勝てるキーワード）",
            "commercial_intent": "中〜高",
        }
    },
    "content_calendar": {
        "week_1": "ハウツー記事 × 2",
        "week_2": "比較記事 × 1 + ユースケース記事 × 1",
        "week_3": "ハウツー記事 × 2",
        "week_4": "事例紹介 × 1 + まとめ記事 × 1",
    },
    "article_template": {
        "structure": [
            "H1: [キーワード]の完全ガイド【2026年最新版】",
            "導入: 課題の共感 + 解決策の提示",
            "H2: [課題]の現状と問題点",
            "H2: 解決方法3選（自社プロダクトを含む）",
            "H2: 具体的な手順（スクショ付き）",
            "H2: よくある質問",
            "CTA: 無料トライアルへの誘導",
        ],
        "word_count": "3000-5000文字",
        "images": "最低5枚（スクショ、図解）",
        "internal_links": "関連記事2-3本 + LP",
    },
    "expected_results": {
        "month_1_3": "月間500-1000 PV",
        "month_4_6": "月間3000-5000 PV",
        "month_7_12": "月間10000+ PV",
        "conversion_rate": "PV → 登録: 2-5%",
    }
}

# Product Hunt ローンチチェックリスト
product_hunt_launch = {
    "pre_launch_2weeks": [
        "Hunter（投稿者）を見つける or 自分でHunterになる",
        "Product Huntアカウントの活動実績を積む（コメント、投票）",
        "ローンチ用のアセット作成:",
        "  - ロゴ（240x240px）",
        "  - サムネイル画像（1270x760px）× 5枚",
        "  - 紹介動画（60秒以内、Loom推奨）",
        "  - タグライン（60文字以内の一文）",
        "  - 説明文（ベネフィット重視、260文字以内）",
        "「Upcoming」ページを作成して事前フォロワー集め",
    ],
    "pre_launch_3days": [
        "友人・知人にローンチ日を告知",
        "Twitter/Xでカウントダウン投稿",
        "Product Hunt コミュニティで関係構築",
        "ローンチ日を火曜日〜木曜日に設定（競合が少ない日）",
    ],
    "launch_day": {
        "time": "太平洋時間 12:01 AM（日本時間 17:01）",
        "actions": [
            "即座にコメント欄で自己紹介と開発ストーリーを投稿",
            "Twitter/X・LinkedIn・各SNSで告知",
            "メーリングリストに通知メール送信",
            "関連Slackコミュニティに共有",
            "コメントへの返信は全て15分以内に",
            "1時間ごとにSNSで進捗報告",
        ]
    },
    "post_launch": [
        "Top 5入りしたら追加のSNS投稿",
        "Product Hunt バッジをサイトに掲載",
        "ローンチ結果の振り返りブログ記事を執筆",
        "新規ユーザーへのウェルカムメール送信",
    ],
    "success_metrics": {
        "good": "100+ upvotes, Top 10",
        "great": "300+ upvotes, Top 5",
        "excellent": "500+ upvotes, Product of the Day",
    }
}

// src/lib/email/onboarding-sequence.ts
import { Resend } from 'resend'
 
const resend = new Resend(process.env.RESEND_API_KEY)
 
interface OnboardingEmail {
  day: number
  subject: string
  template: string
  condition?: (user: any) => boolean
}
 
const ONBOARDING_SEQUENCE: OnboardingEmail[] = [
  {
    day: 0,
    subject: "ようこそ！最初の3分で[プロダクト名]を体験しましょう",
    template: "welcome",
  },
  {
    day: 1,
    subject: "[プロダクト名]で最も人気の機能トップ3",
    template: "top-features",
  },
  {
    day: 3,
    subject: "まだ試していない機能がありますか？",
    template: "feature-discovery",
    condition: (user) => user.usage_count < 3,  // 利用が少ないユーザーのみ
  },
  {
    day: 7,
    subject: "他のユーザーはこう活用しています",
    template: "use-cases",
  },
  {
    day: 14,
    subject: "Proプランで10倍の成果を出しませんか？",
    template: "upgrade-offer",
    condition: (user) => user.plan === 'free' && user.usage_count >= 5,
  },
]
 
export async function processOnboardingEmails() {
  // Supabase Edge Function または cron job で毎日実行
  const { data: users } = await supabase
    .from('profiles')
    .select('*')
    .gte('created_at', new Date(Date.now() - 15 * 86400000).toISOString())
 
  for (const user of users || []) {
    const daysSinceSignup = Math.floor(
      (Date.now() - new Date(user.created_at).getTime()) / 86400000
    )
 
    const emailToSend = ONBOARDING_SEQUENCE.find(
      (email) => email.day === daysSinceSignup
    )
 
    if (!emailToSend) continue
    if (emailToSend.condition && !emailToSend.condition(user)) continue
 
    // 既に送信済みかチェック
    const { data: sent } = await supabase
      .from('email_log')
      .select('id')
      .eq('user_id', user.id)
      .eq('template', emailToSend.template)
      .single()
 
    if (sent) continue
 
    // メール送信
    await resend.emails.send({
      from: 'noreply@yourdomain.com',
      to: user.email,
      subject: emailToSend.subject,
      html: renderTemplate(emailToSend.template, user),
    })
 
    // 送信記録
    await supabase.from('email_log').insert({
      user_id: user.id,
      template: emailToSend.template,
      sent_at: new Date().toISOString(),
    })
  }
}

# 個人開発者向けモニタリングダッシュボード
# 毎朝Slack/メールで送信する日次レポート
 
from datetime import datetime, timedelta
from dataclasses import dataclass
 
 
@dataclass
class DailyReport:
    date: str
    new_signups: int
    active_users: int
    total_generations: int
    api_cost_usd: float
    mrr_jpy: int
    churn_count: int
    error_count: int
    avg_response_time_ms: int
    top_feature_usage: dict
 
 
async def generate_daily_report(supabase) -> DailyReport:
    """日次レポートの自動生成"""
    today = datetime.now().date()
    yesterday = today - timedelta(days=1)
 
    # 新規登録数
    signups = await supabase.from('profiles') \
        .select('id', count='exact') \
        .gte('created_at', yesterday.isoformat()) \
        .lt('created_at', today.isoformat()) \
        .execute()
 
    # アクティブユーザー数
    active = await supabase.from('history') \
        .select('user_id', count='exact') \
        .gte('created_at', yesterday.isoformat()) \
        .execute()
 
    # 総生成数
    generations = await supabase.from('history') \
        .select('id', count='exact') \
        .gte('created_at', yesterday.isoformat()) \
        .execute()
 
    # APIコスト
    tokens = await supabase.from('history') \
        .select('tokens_used') \
        .gte('created_at', yesterday.isoformat()) \
        .execute()
 
    total_tokens = sum(r['tokens_used'] for r in (tokens.data or []))
    api_cost = (total_tokens / 1_000_000) * 18  # 概算 $18/MTok平均
 
    # MRR計算
    pro_users = await supabase.from('profiles') \
        .select('id', count='exact') \
        .eq('plan', 'pro') \
        .execute()
    mrr = (pro_users.count or 0) * 5000  # ¥5,000/月
 
    return DailyReport(
        date=yesterday.isoformat(),
        new_signups=signups.count or 0,
        active_users=active.count or 0,
        total_generations=generations.count or 0,
        api_cost_usd=round(api_cost, 2),
        mrr_jpy=mrr,
        churn_count=0,  # 別途計算
        error_count=0,  # Sentryから取得
        avg_response_time_ms=0,  # ログから計算
        top_feature_usage={},
    )
 
 
def format_slack_message(report: DailyReport) -> str:
    """Slack通知用のフォーマット"""
    mrr_emoji = ":chart_with_upwards_trend:" if report.mrr_jpy > 0 else ":chart:"
 
    return f"""
*Daily Report - {report.date}*
 
{mrr_emoji} *MRR:* ¥{report.mrr_jpy:,}
:busts_in_silhouette: *新規登録:* {report.new_signups}人
:zap: *アクティブ:* {report.active_users}人
:robot_face: *AI生成:* {report.total_generations}回
:money_with_wings: *APIコスト:* ${report.api_cost_usd}
:warning: *エラー:* {report.error_count}件
"""

# BAD: ユーザーの全リクエストに応える
def product_roadmap_bad():
    features = [
        "AI記事生成",        # コア
        "AI画像生成",        # 関連あるが別プロダクト
        "チーム管理",        # 時期尚早
        "API提供",           # まだ早い
        "モバイルアプリ",    # 不要
        "Slack統合",         # 数人しか要望なし
    ]
    # → 開発に6ヶ月、どれも中途半端
 
# GOOD: コア機能を磨き、需要が証明されたものだけ追加
def product_roadmap_good():
    v1 = ["AI記事生成"]  # 1機能を極める
    v2 = ["記事のSEO最適化"]  # コアの拡張
    v3 = ["テンプレート機能"]  # ユーザー要望 Top 1
    # → 各バージョン2-3週間で出荷

# BAD: 安くすれば売れると思い込む
pricing_bad = {
    "price": 500,  # ¥500/月
    "target_users": 2000,  # 2000人必要
    "difficulty": "2000人集めるのは200人の10倍難しい",
    "support_load": "2000人分のサポート = 1人では無理"
}
 
# GOOD: 価値に見合った価格設定
pricing_good = {
    "price": 5000,  # ¥5,000/月
    "target_users": 200,  # 200人で十分
    "value_basis": "月5時間の作業削減 = ¥25,000の価値の20%",
    "support_load": "200人 = 1人で十分管理可能"
}

# BAD: 最新技術を使うことが目的化
tech_focused_bad = {
    "stack": [
        "Kubernetes",          # 個人開発に不要
        "マイクロサービス",     # モノリスで十分
        "独自MLモデル",        # API で十分
        "GraphQL",             # REST で十分
        "Redis Cluster",       # 単一インスタンスで十分
    ],
    "result": "インフラ構築に2ヶ月、プロダクトは未完成"
}
 
# GOOD: 退屈な技術で素早く出荷
tech_focused_good = {
    "stack": [
        "Next.js + Vercel",    # デプロイ0秒
        "Supabase",            # DB + Auth 一発
        "Claude API",          # AIはAPI呼び出し
        "Stripe",              # 課金は丸投げ
    ],
    "result": "4週間でMVP完成、ユーザーに価値提供開始"
}

# BAD: 全てが完璧になるまでリリースしない
perfectionism_bad = {
    "blockers": [
        "デザインがまだ完璧じゃない",
        "エッジケースが全て処理できていない",
        "テストカバレッジが90%に達していない",
        "ドキュメントが完成していない",
        "ロゴが気に入らない",
    ],
    "result": "3ヶ月経ってもリリースできず、モチベーション喪失"
}
 
# GOOD: 80%の完成度で出荷、ユーザーFBで改善
shipping_mindset_good = {
    "mvp_criteria": [
        "コア機能が1つ動く",
        "お金を受け取れる",
        "致命的バグがない",
    ],
    "deferred": [
        "デザイン改善 → ユーザーFB後",
        "追加機能 → 需要確認後",
        "テスト充実 → 安定稼働確認後",
    ],
    "result": "4週間でリリース、リアルなFBを得て改善サイクル開始"
}

# 最低限必要な法的ドキュメント
legal_documents = {
    "利用規約": {
        "必須項目": [
            "サービスの定義と提供範囲",
            "利用料金と支払い条件",
            "禁止事項（不正利用、リバースエンジニアリング等）",
            "知的財産権の帰属（AI生成物の権利）",
            "免責事項（AI出力の正確性について）",
            "サービスの変更・停止の権利",
            "解約・返金ポリシー",
            "準拠法と管轄裁判所",
        ],
        "AI特有の注意": [
            "AI出力は参考情報であり、専門家のアドバイスではない旨",
            "入力データの取り扱い（学習に使わない等）",
            "AI出力に対する著作権の取り扱い",
        ]
    },
    "プライバシーポリシー": {
        "必須項目": [
            "収集する個人情報の種類",
            "個人情報の利用目的",
            "第三者提供の有無（Stripe、Supabase、AI API等）",
            "データの保存期間",
            "ユーザーの権利（削除要求、開示要求等）",
            "Cookieの使用について",
            "お問い合わせ窓口",
        ],
        "GDPR対応（欧州ユーザーがいる場合）": [
            "データ処理の法的根拠",
            "データ保護責任者の情報",
            "EEA域外へのデータ移転について",
            "忘れられる権利への対応",
        ]
    },
    "特定商取引法に基づく表記": {
        "必須項目": [
            "事業者の氏名（法人名）",
            "住所",
            "電話番号",
            "メールアドレス",
            "販売価格",
            "支払い方法",
            "返品・キャンセルポリシー",
        ]
    }
}

# 毎週金曜日に実施する振り返り
weekly_review_template = {
    "metrics": {
        "new_signups": "___人",
        "active_users": "___人",
        "mrr": "¥___",
        "churn": "___人",
        "nps_score": "___",
        "support_tickets": "___件",
        "hours_worked": "___時間",
    },
    "reflection": {
        "wins": [
            "今週の最大の成果は何か？",
            "ユーザーから嬉しいフィードバックはあったか？",
        ],
        "learnings": [
            "今週学んだ最も重要なことは何か？",
            "失敗から何を学んだか？",
        ],
        "next_week": [
            "来週の最優先タスク3つは何か？",
            "やらないと決めたことは何か？（優先順位の低いもの）",
        ],
        "wellbeing": [
            "ストレスレベル（1-10）: ___",
            "モチベーション（1-10）: ___",
            "十分な睡眠は取れているか？",
        ]
    }
}