yamatovision 1.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,253 @@
+/**
+ * InteractiveLogin - 対話的ログイン機能
+ * CommonJS版（musuhi-vscode用）
+ */
+
+const readline = require('readline');
+const { PortalAuthClient } = require('./PortalAuthClient');
+const { TokenManager } = require('./TokenManager');
+const { t, setLanguage } = require('../i18n');
+
+class InteractiveLogin {
+    /**
+     * 対話的ログインのメインフロー（トークンベース認証）
+     */
+    static async performLogin() {
+        try {
+            // Phase 1: 保存されたCLIトークンをチェック
+            console.log(`🔵 ${t('auth.portalAuthTitle')}`);
+            console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+
+            const savedTokenData = await TokenManager.loadToken();
+
+            if (savedTokenData && savedTokenData.token) {
+                console.log(`🔍 ${t('auth.checkingSavedToken')}`);
+
+                // トークン検証
+                const validation = await TokenManager.validateToken(savedTokenData.token);
+                console.log(`   ${t('auth.validationResult')}`, validation);
+
+                if (validation.valid) {
+                    console.log(`🔷 ${t('auth.existingTokenValid')}`);
+
+                    // 検証結果からlanguageを取得して設定
+                    const userLanguage = validation.userInfo?.language || savedTokenData.userInfo?.language || 'ja';
+                    setLanguage(userLanguage);
+
+                    return {
+                        token: savedTokenData.token,
+                        user: { ...validation.userInfo, language: userLanguage },
+                        isFromCache: true
+                    };
+                } else {
+                    console.log(`🟡 ${t('auth.savedTokenInvalid')}`);
+                    // 無効なトークンを削除
+                    await TokenManager.deleteToken();
+                }
+            }
+
+            // Phase 2: CLIトークンが無効/存在しない → 認証フロー
+            console.log('');
+            console.log(`📝 ${t('auth.enterCredentials')}`);
+            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(`❌ ${t('auth.kiLimitExceeded')}`);
+                    console.error(`   ${t('auth.kiLimitCheckPortal')}`);
+                } else {
+                    console.error(`❌ ${t('auth.authError', { error: authResult.error })}`);
+                }
+                process.exit(1);
+            }
+
+            // 認証成功後にユーザー言語を設定
+            const userLanguage = authResult.user?.language || 'ja';
+            setLanguage(userLanguage);
+
+            // Phase 3: CLIトークンを保存
+            console.log(`💾 ${t('auth.savingToken')}`);
+            const tokenSaved = await TokenManager.saveToken(authResult.token, authResult.user);
+
+            if (!tokenSaved) {
+                console.warn(`⚠️  ${t('auth.tokenSaveFailed')}`);
+            } else {
+                console.log(`✅ ${t('auth.tokenSaved')}`);
+            }
+
+            // Phase 4: .envファイルのトークンも更新
+            await this.updateEnvToken(authResult.token);
+
+            return {
+                token: authResult.token,
+                user: authResult.user,
+                isFirstTime: true,
+                isFromCache: false
+            };
+
+        } catch (error) {
+            console.error(`❌ ${t('auth.unexpectedError', { 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(`❌ ${t('auth.invalidEmail')}`);
+                rl.close();
+                process.exit(1);
+            }
+
+            const password = await this.question(rl, 'Password: ');
+
+            if (!password || password.trim().length === 0) {
+                console.error(`❌ ${t('auth.emptyPassword')}`);
+                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(`✅ ${t('auth.authSuccess')}`);
+        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+
+        if (result.user) {
+            console.log(`👤 ${t('auth.userLabel', { name: result.user.name || result.user.email })}`);
+            console.log(`📧 ${t('auth.emailLabel', { email: result.user.email })}`);
+            if (result.user.role) {
+                console.log(`🎭 ${t('auth.roleLabel', { role: result.user.role })}`);
+            }
+        }
+
+        if (result.isFromCache) {
+            console.log(`📦 ${t('auth.usingCachedToken')}`);
+        } else if (result.isFirstTime) {
+            console.log(`🎉 ${t('auth.firstLoginComplete')}`);
+        }
+
+        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        console.log('');
+    }
+
+    /**
+     * ログアウト機能
+     */
+    static async logout() {
+        console.log(`🔵 ${t('auth.logoutTitle')}`);
+        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+
+        try {
+            const confirm = await this.question(rl, t('auth.confirmLogout'));
+
+            if (confirm.toLowerCase() === 'y' || confirm.toLowerCase() === 'yes') {
+                const deleted = await TokenManager.deleteToken();
+
+                if (deleted) {
+                    console.log(`✅ ${t('auth.logoutSuccess')}`);
+                } else {
+                    console.log(`⚠️  ${t('auth.logoutNotFound')}`);
+                }
+            } else {
+                console.log(`❌ ${t('auth.logoutCancelled')}`);
+            }
+
+        } 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(`⚠️  ${t('auth.envUpdateFailed', { error: error.message })}`);
+        }
+    }
+}
+
+module.exports = { InteractiveLogin };

package/lib/auth/PortalAuthClient.js

@@ -0,0 +1,184 @@
+/**
+ * PortalAuthClient - Portal API連携クライアント
+ * CommonJS版（musuhi-vscode用）
+ */
+
+const os = require('os');
+const https = require('https');
+const http = require('http');
+const { URL } = require('url');
+const { t } = require('../i18n');
+
+class PortalAuthClient {
+    static PORTAL_API_URL_PROD = 'https://musuhi-portal-235426778039.asia-northeast1.run.app/api/cli/login';
+    static PORTAL_API_URL_LOCAL = 'https://musuhi-portal-235426778039.asia-northeast1.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(`🔐 ${t('auth.authAttempt', { attempt, max: this.MAX_RETRIES })}`);
+                const response = await this.makeRequest(authRequest);
+
+                if (response.success) {
+                    console.log(`✅ ${t('auth.authOk')}`);
+                    console.log(`📝 ${t('auth.tokenOk')}`);
+                    return {
+                        success: true,
+                        token: response.data.token,
+                        user: {
+                            name: response.data.userName,
+                            role: response.data.userRole,
+                            email: email,
+                            language: response.data.language || 'ja'
+                        }
+                    };
+                } else {
+                    throw new Error(response.message || t('auth.authError', { error: 'unknown' }));
+                }
+
+            } catch (error) {
+                lastError = error;
+                console.error(`❌ ${t('auth.authError', { error: error.message })}`);
+                if (attempt < this.MAX_RETRIES) {
+                    console.log(`⏳ ${t('auth.authRetry', { delay: this.RETRY_DELAY })}`);
+                    await this.sleep(this.RETRY_DELAY);
+                }
+            }
+        }
+
+        return {
+            success: false,
+            error: lastError?.message || t('auth.authError', { error: 'unknown' })
+        };
+    }
+
+    /**
+     * デバイス情報の自動生成
+     */
+    static generateDeviceInfo() {
+        return {
+            deviceName: os.hostname(),
+            platform: os.platform(),
+            arch: os.arch(),
+            userAgent: 'むすひ 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': 'むすひ VSCode Extension',
+                    'Accept': 'application/json'
+                },
+                timeout: this.REQUEST_TIMEOUT,
+                rejectUnauthorized: !this.isLocalDev()  // 開発環境のみ自己署名証明書を許可
+            };
+
+            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(t('auth.responseParseError', { error: e.message })));
+                            }
+                            return;
+                        }
+
+                        // ステータスコードが200以外の場合
+                        if (res.statusCode !== 200) {
+                            if (response && response.message) {
+                                reject(new Error(response.message));
+                            } else {
+                                reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`));
+                            }
+                            return;
+                        }
+
+                        resolve(response);
+
+                    } catch (error) {
+                        reject(new Error(t('auth.responseParseError', { error: error.message })));
+                    }
+                });
+            });
+
+            req.on('error', (error) => {
+                reject(new Error(t('auth.networkError', { error: error.message })));
+            });
+
+            req.on('timeout', () => {
+                req.destroy();
+                reject(new Error(t('auth.requestTimeout')));
+            });
+
+            req.write(postData);
+            req.end();
+        });
+    }
+
+    /**
+     * スリープ関数
+     */
+    static sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+
+module.exports = { PortalAuthClient };