bluelamp 3.0.8 → 4.0.0

package/lib/agents//343/203/226/343/203/253/343/203/274/343/203/251/343/203/263/343/203/227.md

@@ -0,0 +1,106 @@
+---
+name: ブルーランプ
+description: パフォーマーエージェント - オーケストレーターの指示に応じて適切な役割・ツールを選択・実行
+model: sonnet
+color: blue
+---
+
+# ブルーランプエージェント
+
+
+1. **初期化**:オーケストレーターから指示があった場合は、inject_knowledge(keyword: "キーワード")こちらで指示通りの知識を注入する（指示がなければ不要）
+2. **オーケストレーター指示の確認**: タスク指示を解析し、実行内容を特定
+3. **タスク実行**: 注入された専門知識に基づいて適切な処理を実行
+
+## 🌟 基本理念
+「シンプルさは究極の洗練である」- レオナルド・ダ・ヴィンチ
+「プロジェクトでいまここに不要なコードは一文字も残さない」
+「最高の仕様書はドキュメントではなく美しく整ったアーキテクチャのコードそのものである」
+「秩序を保つことに責任を持つ。整理整頓された綺麗な部屋のようにコードやドキュメントの片付け整理を忘れない」
+「ジョブスのように誰もみてない細部のコードの美しさにも職人のようにこだわる」
+## 🎯 5つの核心原則
+
+### 1. 最小性の原則（Principle of Minimalism）
+**「必要最小限を超えない」**
+- 新規作成より既存活用を優先する
+- 解決策は常に最もシンプルなものを選ぶ
+- あったらいいなはないほうがいい
+
+### 2. 単一性の原則（Principle of Singularity）
+**「真実の源は常に一つ」**
+- SQLAlchemyモデルはbackend/app/models/__init__.pyに集約（DB定義の単一源）
+- 実装計画はSCOPE_PROGRESS.mdに集約させる
+- 仕様書やロジックなどはrequirements.mdに集約させる
+
+### 3. 刹那性の原則（Principle of Ephemerality）
+**「今、ここで必要なものだけを残す」**
+- 役目を終えたものは即座に削除する
+- 修正や変更により使わなくなったコードは即リファクタリング
+- 後方互換の原則禁止(ただし修正時は安全を確保するよう慎重に)
+- 未来の「もしかして」のために保持しない
+- 生きているコードとドキュメントのみを維持する
+
+### 4. 実証性の原則（Principle of Evidence）
+**「事実こそが真実への唯一の道」**
+- 環境変数やデータベースを積極的に確認する。
+- 開発環境でもバックエンドは全て本番のAPIを使って検証テスト作成する。バックエンドのモック絶対禁止。
+- デバッグで明確に原因がわからない場合はログを設置する。推測しない。
+- 外部APIや比較的新しい技術はweb検索を積極的に活用する。仕様を推測しない。
+- **Web検索前に必ず`date`コマンドで現在日時を確認し、現在の最新情報を検索する**
+
+### 5. 潔癖性の原則（Principle of Fail-Fast）
+**「失敗は隠すな、早く明確に、透明に失敗せよ」**
+- エラーは即座に表面化させる
+- フォールバックによる問題の隠蔽を禁止する
+- そもそもフォールバック不要のシンプルで堅牢性の高い構造を作る
+
+## ドキュメント管理の原則
+
+単一の真実源の原則を守らせ、勝手なドキュメントを無作為に作らせないように制御してください。
+- **docs/SCOPE_PROGRESS.md**: 今これからやるべき実装の計画
+- **docs/requirements.md**: 今これからやるべき実装の詳細
+- **docs/DEPLOYMENT.md**: デプロイ情報
+- **docs/designsystem.md**: デザインシステム
+- **docs/api-specs/[ページ名]-api.md**: API仕様書
+
+例えばリサーチして何か知見があり、その結果としてドキュメント化したいのであれば
+requirements.md(要件やロジック)
+SCOPE_PROGRESS.md(実装計画)
+
+こちらにのみ記載可能であり、こちらに記載する価値がなければ回答のみで報告してください。
+これ以外のドキュメントはユーザーへの確認と明確な許諾や指示がない限り作成してはいけません。
+
+requirements.md(要件やロジック)
+SCOPE_PROGRESS.md(実装計画)
+
+こちらは実装が完了しコードに落とし込まれている記載は積極的に削除し不要な記載はなくす。
+
+## 🔧 FastAPI + SQLAlchemy開発の絶対原則
+
+  ### 6. 環境変数の絶対原則
+  - **開発中は全ての場面で.env.localのみ使用**
+  - テストスクリプトは必ず.env.localを読み込ませる
+  - .env.test、.env.developmentなど作らない
+  - DATABASE_URLは.env.localの1箇所のみ
+
+  ### 7. SQLAlchemy/DBの絶対原則
+  - **SQLAlchemyエラーが出たら`alembic upgrade head`を実行**
+  - スキーマ変更は`alembic revision --autogenerate`後に`alembic upgrade head`
+  - SQLAlchemyモデルはbackend/app/models/__init__.pyに集約
+  - **DBURLエラー時は環境変数エラーとして即報告**
+
+  ### 8. テストも.env.localを使用
+  - テスト専用DBは作らない
+  - 同じDBで問題なし（開発段階）
+  - process.env.DATABASE_URLをそのまま使用
+
+  ### 9. サーバー起動の絶対原則
+  - サーバーは1つ維持
+  - 再起動禁止（ホットリロードを使う）
+  - 既存サーバーがある場合はそれを使う
+    （理由：複数エージェントで同プロジェクトを扱うため、既存サーバーのほとんどは同じプロジェクト。失敗時のみ調査し、違う場合のみ新規起動）
+
+  ### 10. エラー時の絶対原則
+  - **環境変数エラー** → 全タスク強制終了し即座に報告（試行錯誤禁止）
+  - **SQLAlchemy接続エラー** → `alembic upgrade head`後、1回だけ再試行
+  - **3回同じエラー** → Web検索を許可

package/lib/auth/InteractiveLogin.js

@@ -0,0 +1,243 @@
+/**
+ * InteractiveLogin - 対話的ログイン機能
+ * CommonJS版（bluelamp-vscode用）
+ */
+
+const readline = require('readline');
+const { PortalAuthClient } = require('./PortalAuthClient');
+const { TokenManager } = require('./TokenManager');
+
+class InteractiveLogin {
+    /**
+     * 対話的ログインのメインフロー（トークンベース認証）
+     */
+    static async performLogin() {
+        try {
+            // Phase 1: 保存されたCLIトークンをチェック
+            console.log('🔵 BlueLamp VSCode - Portal認証');
+            console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+
+            const savedTokenData = await TokenManager.loadToken();
+
+            if (savedTokenData && savedTokenData.token) {
+                console.log('🔍 保存されたトークンを確認中...');
+
+                // トークン検証
+                const validation = await TokenManager.validateToken(savedTokenData.token);
+                console.log('   検証結果:', validation);
+
+                if (validation.valid) {
+                    console.log('🔷 既存のトークンが有効です');
+                    return {
+                        token: savedTokenData.token,
+                        user: validation.userInfo,
+                        isFromCache: true
+                    };
+                } else {
+                    console.log('🟡 保存されたトークンが無効です');
+                    // 無効なトークンを削除
+                    await TokenManager.deleteToken();
+                }
+            }
+
+            // Phase 2: CLIトークンが無効/存在しない → 認証フロー
+            console.log('');
+            console.log('📝 Portalログイン情報を入力してください');
+            console.log('');
+
+            // 対話的ログイン情報入力
+            const credentials = await this.promptCredentials();
+
+            // Portal API認証
+            const authResult = await PortalAuthClient.authenticate(
+                credentials.email,
+                credentials.password
+            );
+
+            if (!authResult.success) {
+                // エラーメッセージの処理
+                if (authResult.error && authResult.error.includes('ナレッジインジェクション使用回数上限')) {
+                    console.error('');
+                    console.error('❌ ナレッジインジェクション使用回数が上限に達しています');
+                    console.error('   Portalで使用状況を確認してください');
+                } else {
+                    console.error('❌ 認証エラー:', authResult.error);
+                }
+                process.exit(1);
+            }
+
+            // Phase 3: CLIトークンを保存
+            console.log('💾 トークンを保存中...');
+            const tokenSaved = await TokenManager.saveToken(authResult.token, authResult.user);
+
+            if (!tokenSaved) {
+                console.warn('⚠️  トークン保存に失敗しました（認証は成功）');
+            } else {
+                console.log('✅ トークンを安全に保存しました');
+            }
+
+            // Phase 4: .envファイルのトークンも更新
+            await this.updateEnvToken(authResult.token);
+
+            return {
+                token: authResult.token,
+                user: authResult.user,
+                isFirstTime: true,
+                isFromCache: false
+            };
+
+        } catch (error) {
+            console.error('❌ 予期しないエラー:', error.message);
+            process.exit(1);
+        }
+    }
+
+    /**
+     * ログイン情報の対話的入力
+     */
+    static async promptCredentials() {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+
+        try {
+            const email = await this.question(rl, 'Email: ');
+
+            if (!this.validateEmail(email)) {
+                console.error('❌ 無効なメールアドレス形式です');
+                rl.close();
+                process.exit(1);
+            }
+
+            const password = await this.question(rl, 'Password: ');
+
+            if (!password || password.trim().length === 0) {
+                console.error('❌ パスワードが入力されていません');
+                rl.close();
+                process.exit(1);
+            }
+
+            rl.close();
+
+            return {
+                email: email.trim(),
+                password: password.trim()
+            };
+
+        } catch (error) {
+            rl.close();
+            throw error;
+        }
+    }
+
+    /**
+     * readline.question のPromise版
+     */
+    static question(rl, prompt) {
+        return new Promise((resolve) => {
+            rl.question(prompt, (answer) => {
+                resolve(answer);
+            });
+        });
+    }
+
+    /**
+     * メールアドレスの簡易バリデーション
+     */
+    static validateEmail(email) {
+        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+        return emailRegex.test(email);
+    }
+
+    /**
+     * ログイン成功時の情報表示
+     */
+    static displayLoginSuccess(result) {
+        console.log('');
+        console.log('✅ Portal認証成功');
+        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+
+        if (result.user) {
+            console.log(`👤 ユーザー: ${result.user.name || result.user.email}`);
+            console.log(`📧 Email: ${result.user.email}`);
+            if (result.user.role) {
+                console.log(`🎭 ロール: ${result.user.role}`);
+            }
+        }
+
+        if (result.isFromCache) {
+            console.log('📦 保存済みトークンを使用');
+        } else if (result.isFirstTime) {
+            console.log('🎉 初回ログイン完了');
+        }
+
+        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        console.log('');
+    }
+
+    /**
+     * ログアウト機能
+     */
+    static async logout() {
+        console.log('🔵 BlueLamp VSCode - ログアウト');
+        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+
+        try {
+            const confirm = await this.question(rl, 'ログイン情報を削除しますか？ (y/N): ');
+
+            if (confirm.toLowerCase() === 'y' || confirm.toLowerCase() === 'yes') {
+                const deleted = await TokenManager.deleteToken();
+
+                if (deleted) {
+                    console.log('✅ ログイン情報を削除しました');
+                } else {
+                    console.log('⚠️  ログイン情報が見つかりません');
+                }
+            } else {
+                console.log('❌ キャンセルしました');
+            }
+
+        } finally {
+            rl.close();
+        }
+    }
+
+    /**
+     * .envファイルのトークンを更新
+     */
+    static async updateEnvToken(newToken) {
+        const fs = require('fs');
+        const path = require('path');
+
+        try {
+            const envPath = path.join(__dirname, '../../.env');
+
+            if (fs.existsSync(envPath)) {
+                let envContent = fs.readFileSync(envPath, 'utf8');
+
+                // BLUELAMP_TOKENの行を更新
+                if (envContent.includes('BLUELAMP_TOKEN=')) {
+                    envContent = envContent.replace(
+                        /BLUELAMP_TOKEN=.*/,
+                        `BLUELAMP_TOKEN=${newToken}`
+                    );
+                } else {
+                    // BLUELAMP_TOKENの行が存在しない場合は追加
+                    envContent += `\nBLUELAMP_TOKEN=${newToken}`;
+                }
+
+                fs.writeFileSync(envPath, envContent);
+            }
+        } catch (error) {
+            console.warn('⚠️  .envファイルの更新に失敗:', error.message);
+        }
+    }
+}
+
+module.exports = { InteractiveLogin };

package/lib/auth/PortalAuthClient.js

@@ -0,0 +1,187 @@
+/**
+ * PortalAuthClient - Portal API連携クライアント
+ * CommonJS版（bluelamp-vscode用）
+ */
+
+const os = require('os');
+const https = require('https');
+const http = require('http');
+const { URL } = require('url');
+
+class PortalAuthClient {
+    static PORTAL_API_URL_PROD = 'https://bluelamp-6clpzmy5pa-an.a.run.app/api/cli/login';
+    static PORTAL_API_URL_LOCAL = 'https://bluelamp-6clpzmy5pa-an.a.run.app/api/cli/login';
+    static MAX_RETRIES = 3;
+    static RETRY_DELAY = 1000; // 1秒
+    static REQUEST_TIMEOUT = 10000; // 10秒
+
+    /**
+     * 開発環境かどうかを判定
+     */
+    static isLocalDev() {
+        return process.env.PORTAL_URL && process.env.PORTAL_URL.includes('localhost');
+    }
+
+    /**
+     * APIエンドポイントを取得
+     */
+    static getApiUrl() {
+        return this.isLocalDev() ? this.PORTAL_API_URL_LOCAL : this.PORTAL_API_URL_PROD;
+    }
+
+    /**
+     * Portal API認証・CLIトークン取得
+     */
+    static async authenticate(email, password) {
+        const deviceInfo = this.generateDeviceInfo();
+        const authRequest = {
+            email: email,
+            password: password,
+            deviceInfo: deviceInfo
+        };
+
+        let lastError = null;
+
+        for (let attempt = 1; attempt <= this.MAX_RETRIES; attempt++) {
+            try {
+                console.log(`🔐 認証試行 ${attempt}/${this.MAX_RETRIES}...`);
+                const response = await this.makeRequest(authRequest);
+
+                if (response.success) {
+                    console.log('✅ Portal認証成功');
+                    console.log('📝 トークン取得成功');
+                    return {
+                        success: true,
+                        token: response.data.token,
+                        user: {
+                            name: response.data.userName,
+                            role: response.data.userRole,
+                            email: email
+                        }
+                    };
+                } else {
+                    throw new Error(response.message || 'Portal認証に失敗しました');
+                }
+
+            } catch (error) {
+                lastError = error;
+                console.error(`❌ 認証エラー: ${error.message}`);
+                if (attempt < this.MAX_RETRIES) {
+                    console.log(`⏳ ${this.RETRY_DELAY}ms後にリトライ...`);
+                    await this.sleep(this.RETRY_DELAY);
+                }
+            }
+        }
+
+        return {
+            success: false,
+            error: lastError?.message || 'Portal認証に失敗しました'
+        };
+    }
+
+    /**
+     * デバイス情報の自動生成
+     */
+    static generateDeviceInfo() {
+        return {
+            deviceName: os.hostname(),
+            platform: os.platform(),
+            arch: os.arch(),
+            userAgent: 'BlueLamp VSCode Extension',
+            nodeVersion: process.version,
+            timestamp: Date.now()
+        };
+    }
+
+    /**
+     * HTTP/HTTPS リクエストの実行
+     */
+    static async makeRequest(authRequest) {
+        return new Promise((resolve, reject) => {
+            const url = new URL(this.getApiUrl());
+            const postData = JSON.stringify(authRequest);
+
+            const options = {
+                hostname: url.hostname,
+                port: url.port || (url.protocol === 'https:' ? 443 : 80),
+                path: url.pathname,
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Content-Length': Buffer.byteLength(postData),
+                    'User-Agent': 'BlueLamp VSCode Extension',
+                    'Accept': 'application/json'
+                },
+                timeout: this.REQUEST_TIMEOUT,
+                rejectUnauthorized: false  // 自己署名証明書を許可
+            };
+
+            const client = url.protocol === 'https:' ? https : http;
+
+            const req = client.request(options, (res) => {
+                let data = '';
+
+                res.on('data', (chunk) => {
+                    data += chunk;
+                });
+
+                res.on('end', () => {
+                    try {
+                        let response;
+                        try {
+                            response = JSON.parse(data);
+                        } catch (e) {
+                            if (res.statusCode !== 200) {
+                                reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`));
+                            } else {
+                                reject(new Error(`レスポンス解析エラー: ${e.message}`));
+                            }
+                            return;
+                        }
+
+                        // ステータスコードが200以外の場合
+                        if (res.statusCode !== 200) {
+                            if (response && response.message) {
+                                // 使用回数制限エラーの場合
+                                if (response.error === 'KNOWLEDGE_INJECTION_LIMIT_EXCEEDED') {
+                                    reject(new Error(response.message));
+                                } else {
+                                    reject(new Error(response.message));
+                                }
+                            } else {
+                                reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`));
+                            }
+                            return;
+                        }
+
+                        resolve(response);
+
+                    } catch (error) {
+                        reject(new Error(`レスポンス解析エラー: ${error.message}`));
+                    }
+                });
+            });
+
+            req.on('error', (error) => {
+                reject(new Error(`ネットワークエラー: ${error.message}`));
+            });
+
+            req.on('timeout', () => {
+                req.destroy();
+                reject(new Error('リクエストタイムアウト'));
+            });
+
+            req.write(postData);
+            req.end();
+        });
+    }
+
+    /**
+     * スリープ関数
+     */
+    static sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+
+module.exports = { PortalAuthClient };