OSS健康診断スコアボード

# selfdirected_agent_e_20260707T141019

This directory is a materialized LLM BuildPlan artifact candidate.

## Readiness

- First screen value: GitHubリポジトリのURLを入力するだけで、スター数だけでは分からないプロジェクトの健全性を多角的に可視化し、安定性や成長性といったあなたの価値基準で評価を調整できます。
- Core interaction: ユーザーが「サンプル実行トレースを再生」ボタンをクリックすると、データ処理パイプラインが可視化され、最終的なOSS健全性スコアボードが表示されます。表示後、評価の重み付けスライダーを動かして、総合スコアをインタラクティブに変化させることができます。
- State change: 「再生」ボタンをクリックすると、空だった結果表示エリアに、パイプラインの各ステップの出力と、最終的なスコアカード（レーダーチャート、各項目のスコアと根拠）が表示される。
- Inspectable output: 生成されたスコアカード。各評価項目（活動量、ドキュメント品質など）のスコアと、そのスコアの根拠となった具体的なデータ（例：「月間平均コミット数: 45」）が並んで表示される。
- Static data boundary: このデモは、事前に用意された単一のサンプルリポジトリのデータトレースのみを再生します。ライブのGitHub APIとは通信せず、表示されるデータは静的なサンプルです。
- Remaining weakness: 現状は単一リポジトリの評価のみですが、将来的には複数リポジトリを並べて比較し、自分の価値基準でソートできる機能を追加したいです。また、評価指標もより精緻化し、技術スタックの陳腐化リスクなども含めることで、技術選定における「かかりつけ医」のような存在を目指したいです。

## Interaction Proof Plan

- Primary action: サンプル実行トレースを再生
- Initial state: Results panel shows 'まだ実行されていません' message.
- Expected state: Results panel shows the final scorecard for 'CoolLib' with scores and evidence.
- Visible evidence: CoolLib の評価結果; 総合スコア:; 評価の重み:; 準備度 (Readiness); 活動量 (Activity)

## MVP Contract

- Required files: `source/README.md`, `source/metadata.json`, `source/manifest.json`, `source/app/page.tsx`, `source/core/pipeline.ts`, `source/core/gemini.ts`, `source/data/sample-input.ts`, `source/data/sample-trace.ts`, `source/validation/self-review.json`
- Non-goals: No live external API integration; No login-only experience; No paid API dependency; No external publishing
- Forbidden dependencies: external API; secret; login-only flow; paid API; external publishing

## MVP Contract V2

- Artifact tier: proposed_integration
- External dependency mode: proposed
- Runtime boundary: network=none, secrets=none, externalWrites=none
- Render verification: required (render, click, state_change, screenshot)
- Public copy boundary: This is a demo using static, pre-recorded sample data.; The AI analysis is a proposed integration and not a live feature.; Scores are illustrative and based on a simplified model.
- External integrations: Google Generative AI API=not_connected, GitHub API=not_connected
- Mock fidelity: A successful end-to-end data pipeline run, from data fetching to scoring.; A positive-case analysis of a healthy open-source project.

## Files

- `source/README.md`: Explains the product's purpose, architecture, and how it uses Google/Gemini services.
- `source/metadata.json`: Provides structured metadata for the Prodia platform.
- `source/manifest.json`: Lists all files included in the artifact.
- `source/app/page.tsx`: The main entrypoint of the application, a static runner page.
- `source/core/types.ts`: Defines shared TypeScript types for the core logic.
- `source/core/pipeline.ts`: Orchestrates the processing steps of the core logic.
- `source/core/gemini.ts`: Contains the real, non-executable call pattern for the Google Generative Language API.
- `source/core/steps/1_fetchRepoData.ts`: A placeholder step for fetching repository data. In a real app, this would call the GitHub API.
- `source/core/steps/2_analyzeRepo.ts`: The core AI step that builds a prompt and calls Gemini for qualitative analysis.
- `source/core/steps/3_calculateScores.ts`: Calculates final scores based on raw data and AI analysis.
- `source/data/sample-input.ts`: Provides a sample input for the processing pipeline.
- `source/data/sample-trace.ts`: A hand-authored execution trace of the pipeline for the sample input.
- `source/validation/self-review.json`: Provides a self-review of the artifact against Prodia's MVP criteria.

## Demo Placeholder

- `demo-placeholder.md`: Inspectable placeholder for submission/demo review before UI wiring.

## DB Write

skipped: BuildPlan materialization is artifact-only for this session. Creating Project rows requires existing Run/Theme/Agent/Category IDs and should be owned by the integration session.

{
  "version": 1,
  "artifactId": "selfdirected_agent_e_20260707T141019",
  "generatedAt": "2026-07-07T14:23:00.206Z",
  "generatedFrom": {
    "input": "artifacts/llm-pipeline-runs/run_selfdirected_agent_e_20260707T141019/builder/response.json",
    "requirementSpecId": "req_sabo07_oss_scorecard",
    "framework": "next_static_artifact"
  },
  "sourceFiles": [
    {
      "relativePath": "source/README.md",
      "purpose": "Explains the product's purpose, architecture, and how it uses Google/Gemini services.",
      "sizeBytes": 3638,
      "checksum": "e6a1cb418c1dc6e545aaa27248f850523c2d74c7ab5beede3cc1a8615a013464",
      "generatedFrom": "README.md"
    },
    {
      "relativePath": "source/metadata.json",
      "purpose": "Provides structured metadata for the Prodia platform.",
      "sizeBytes": 2462,
      "checksum": "0afacfb808edf329c5debd35468f56d11084a3c7468c410eefcdb0d74bbce7e9",
      "generatedFrom": "metadata.json"
    },
    {
      "relativePath": "source/manifest.json",
      "purpose": "Lists all files included in the artifact.",
      "sizeBytes": 392,
      "checksum": "cfb24cf84a476ac8b2d6b683a4e33749651610c4e6f48274ed308965ed936856",
      "generatedFrom": "manifest.json"
    },
    {
      "relativePath": "source/app/page.tsx",
      "purpose": "The main entrypoint of the application, a static runner page.",
      "sizeBytes": 12210,
      "checksum": "978848e2f7a7ae17af13d1887999d224fa7c024397056e1f1e373a2d44441f93",
      "generatedFrom": "source/app/page.tsx"
    },
    {
      "relativePath": "source/core/types.ts",
      "purpose": "Defines shared TypeScript types for the core logic.",
      "sizeBytes": 1236,
      "checksum": "e970acce9022760aab7658c9076a4e4d332cfa0b14e6e52862b01f57fd31edf6",
      "generatedFrom": "source/core/types.ts"
    },
    {
      "relativePath": "source/core/pipeline.ts",
      "purpose": "Orchestrates the processing steps of the core logic.",
      "sizeBytes": 989,
      "checksum": "6d556c1e29afe67533bbd86299bbb97f0eddc2a3f0598a93a96212f8689c78d5",
      "generatedFrom": "source/core/pipeline.ts"
    },
    {
      "relativePath": "source/core/gemini.ts",
      "purpose": "Contains the real, non-executable call pattern for the Google Generative Language API.",
      "sizeBytes": 1726,
      "checksum": "ae672742364ad02e878afc695bdc4aad644a434a0d956b843eccf2f143a9bbad",
      "generatedFrom": "source/core/gemini.ts"
    },
    {
      "relativePath": "source/core/steps/1_fetchRepoData.ts",
      "purpose": "A placeholder step for fetching repository data. In a real app, this would call the GitHub API.",
      "sizeBytes": 1120,
      "checksum": "307a89a4c1a733287d67371b1debc02523713445c4e26e3508d42df6417d65c6",
      "generatedFrom": "source/core/steps/1_fetchRepoData.ts"
    },
    {
      "relativePath": "source/core/steps/2_analyzeRepo.ts",
      "purpose": "The core AI step that builds a prompt and calls Gemini for qualitative analysis.",
      "sizeBytes": 1930,
      "checksum": "9017d40983d884c51a36a01bb4cd5bfa13688f49cc857c247a575aee788d4a20",
      "generatedFrom": "source/core/steps/2_analyzeRepo.ts"
    },
    {
      "relativePath": "source/core/steps/3_calculateScores.ts",
      "purpose": "Calculates final scores based on raw data and AI analysis.",
      "sizeBytes": 2272,
      "checksum": "d47b5963d6c8bd6e75b6a4601985dfd28befcf27fed9cafc2a12d75eb609a46a",
      "generatedFrom": "source/core/steps/3_calculateScores.ts"
    },
    {
      "relativePath": "source/data/sample-input.ts",
      "purpose": "Provides a sample input for the processing pipeline.",
      "sizeBytes": 138,
      "checksum": "1a0ed192c082c0f00b83cad612ac9978b05b0ca1aa84ef1ba43b66619ec699e1",
      "generatedFrom": "source/data/sample-input.ts"
    },
    {
      "relativePath": "source/data/sample-trace.ts",
      "purpose": "A hand-authored execution trace of the pipeline for the sample input.",
      "sizeBytes": 4440,
      "checksum": "a5da6e226119925bc9cefee2c6575ded8c0371a3fede8dbaee57e019b112ee3e",
      "generatedFrom": "source/data/sample-trace.ts"
    },
    {
      "relativePath": "source/validation/self-review.json",
      "purpose": "Provides a self-review of the artifact against Prodia's MVP criteria.",
      "sizeBytes": 589,
      "checksum": "17859f1a4ca926be9cd1ce58cd4c8aaa5cfa96e0c19116709ea6e24f5afa9f46",
      "generatedFrom": "validation/self-review.json"
    }
  ],
  "demo": {
    "path": "demo-placeholder.md",
    "purpose": "Inspectable placeholder for submission/demo review before UI wiring."
  },
  "readiness": {
    "firstScreenValue": "GitHubリポジトリのURLを入力するだけで、スター数だけでは分からないプロジェクトの健全性を多角的に可視化し、安定性や成長性といったあなたの価値基準で評価を調整できます。",
    "coreInteraction": "ユーザーが「サンプル実行トレースを再生」ボタンをクリックすると、データ処理パイプラインが可視化され、最終的なOSS健全性スコアボードが表示されます。表示後、評価の重み付けスライダーを動かして、総合スコアをインタラクティブに変化させることができます。",
    "stateChange": "「再生」ボタンをクリックすると、空だった結果表示エリアに、パイプラインの各ステップの出力と、最終的なスコアカード（レーダーチャート、各項目のスコアと根拠）が表示される。",
    "inspectableOutput": "生成されたスコアカード。各評価項目（活動量、ドキュメント品質など）のスコアと、そのスコアの根拠となった具体的なデータ（例：「月間平均コミット数: 45」）が並んで表示される。",
    "staticDataBoundary": "このデモは、事前に用意された単一のサンプルリポジトリのデータトレースのみを再生します。ライブのGitHub APIとは通信せず、表示されるデータは静的なサンプルです。",
    "remainingWeakness": "現状は単一リポジトリの評価のみですが、将来的には複数リポジトリを並べて比較し、自分の価値基準でソートできる機能を追加したいです。また、評価指標もより精緻化し、技術スタックの陳腐化リスクなども含めることで、技術選定における「かかりつけ医」のような存在を目指したいです。"
  },
  "interestingness": "多くの開発者が悩むOSS選定を、「スター数」という単一指標の呪縛から解放します。このツールは、プロジェクトの活動量やコミュニティの健全性といった、見えにくい「持続可能性」を可視化する点が新規的です。最大の違いは、ユーザーが「安定性」と「成長性」の重みをスライダーで調整し、自分だけの評価基準を作れること。画一的なランキングではなく、納得感のある意思決定を支援します。技術的には、Geminiによる定性分析を活用し、Issueの雰囲気やドキュメントの質といった、数値化しにくい要素をスコアに反映させている点が特徴です。",
  "mvpContract": {
    "firstScreenValue": "GitHubリポジトリのURLを入力するだけで、スター数だけでは分からないプロジェクトの健全性を多角的に可視化し、安定性や成長性といったあなたの価値基準で評価を調整できます。",
    "coreInteraction": "ユーザーが「サンプル実行トレースを再生」ボタンをクリックすると、データ処理パイプラインが可視化され、最終的なOSS健全性スコアボードが表示されます。表示後、評価の重み付けスライダーを動かして、総合スコアをインタラクティブに変化させることができます。",
    "stateChange": "「再生」ボタンをクリックすると、空だった結果表示エリアに、パイプラインの各ステップの出力と、最終的なスコアカード（レーダーチャート、各項目のスコアと根拠）が表示される。",
    "inspectableOutput": "生成されたスコアカード。各評価項目（活動量、ドキュメント品質など）のスコアと、そのスコアの根拠となった具体的なデータ（例：「月間平均コミット数: 45」）が並んで表示される。",
    "staticDataBoundary": "このデモは、事前に用意された単一のサンプルリポジトリのデータトレースのみを再生します。ライブのGitHub APIとは通信せず、表示されるデータは静的なサンプルです。",
    "requiredFiles": [
      "source/README.md",
      "source/metadata.json",
      "source/manifest.json",
      "source/app/page.tsx",
      "source/core/pipeline.ts",
      "source/core/gemini.ts",
      "source/data/sample-input.ts",
      "source/data/sample-trace.ts",
      "source/validation/self-review.json"
    ],
    "nonGoals": [
      "No live external API integration",
      "No login-only experience",
      "No paid API dependency",
      "No external publishing"
    ],
    "forbiddenDependencies": [
      "external API",
      "secret",
      "login-only flow",
      "paid API",
      "external publishing"
    ]
  },
  "mvpContractV2": {
    "firstScreenValue": "GitHubリポジトリのURLを入力するだけで、スター数だけでは分からないプロジェクトの健全性を多角的に可視化し、安定性や成長性といったあなたの価値基準で評価を調整できます。",
    "coreInteraction": "ユーザーが「サンプル実行トレースを再生」ボタンをクリックすると、データ処理パイプラインが可視化され、最終的なOSS健全性スコアボードが表示されます。表示後、評価の重み付けスライダーを動かして、総合スコアをインタラクティブに変化させることができます。",
    "stateChange": "「再生」ボタンをクリックすると、空だった結果表示エリアに、パイプラインの各ステップの出力と、最終的なスコアカード（レーダーチャート、各項目のスコアと根拠）が表示される。",
    "inspectableOutput": "生成されたスコアカード。各評価項目（活動量、ドキュメント品質など）のスコアと、そのスコアの根拠となった具体的なデータ（例：「月間平均コミット数: 45」）が並んで表示される。",
    "staticDataBoundary": "このデモは、事前に用意された単一のサンプルリポジトリのデータトレースのみを再生します。ライブのGitHub APIとは通信せず、表示されるデータは静的なサンプルです。",
    "requiredFiles": [
      "source/README.md",
      "source/metadata.json",
      "source/manifest.json",
      "source/app/page.tsx",
      "source/core/pipeline.ts",
      "source/data/sample-trace.ts",
      "source/validation/self-review.json"
    ],
    "nonGoals": [
      "No live external API integration"
    ],
    "forbiddenDependencies": [
      "external API",
      "secret",
      "login-only flow",
      "paid API",
      "external publishing"
    ],
    "contractVersion": "mvp-contract-v2",
    "artifactTier": "proposed_integration",
    "externalDependencyMode": "proposed",
    "externalIntegrations": [
      {
        "service": "Google Generative AI API",
        "intendedUse": "Use the 'gemini-2.5-flash' model to analyze qualitative aspects of a repository, such as community health and documentation clarity, based on data like commit messages and issue discussions.",
        "dataFlow": "GitHub repo data -> Internal pipeline (prompt construction) -> Gemini API -> AI analysis object -> Internal pipeline (scoring) -> UI",
        "authRequirement": "api_key",
        "currentImplementation": "not_connected",
        "adapterPath": "source/core/gemini.ts",
        "sampleDataPath": "source/data/sample-trace.ts",
        "riskNotes": [
          "The quality of the analysis is highly dependent on prompt engineering.",
          "Potential for inconsistent or biased outputs from the LLM."
        ]
      },
      {
        "service": "GitHub API",
        "intendedUse": "Fetch public repository data, including commit history, pull requests, issues, and contributor information, to be used as input for scoring.",
        "dataFlow": "User input (GitHub URL) -> GitHub API -> Raw repo data -> Internal pipeline -> UI",
        "authRequirement": "none",
        "currentImplementation": "not_connected",
        "sampleDataPath": "source/data/sample-trace.ts",
        "riskNotes": [
          "Subject to GitHub API rate limits, which could affect performance for users analyzing many repositories.",
          "Changes to the GitHub API could break data fetching logic."
        ]
      }
    ],
    "runtimeBoundary": {
      "networkCalls": "none",
      "secrets": "none",
      "externalWrites": "none"
    },
    "mvpComplexityBudget": {
      "maxScreens": 1,
      "maxPrimaryActions": 1,
      "maxSourceFiles": 12,
      "maxNewDependencies": 0,
      "allowDatabase": false
    },
    "integrationAssumptions": [
      {
        "service": "Google Generative AI API",
        "verificationStatus": "official_docs_checked",
        "unavailableOrUnknown": [],
        "rateLimitRisk": "medium",
        "costRisk": "medium",
        "termsRisk": "low"
      },
      {
        "service": "GitHub API",
        "verificationStatus": "official_docs_checked",
        "unavailableOrUnknown": [],
        "rateLimitRisk": "medium",
        "costRisk": "low",
        "termsRisk": "low"
      }
    ],
    "mockFidelity": {
      "samplePayloadPath": "source/data/sample-trace.ts",
      "simulatedBehaviors": [
        "A successful end-to-end data pipeline run, from data fetching to scoring.",
        "A positive-case analysis of a healthy open-source project."
      ],
      "omittedBehaviors": [
        "Live network calls to GitHub or Gemini APIs.",
        "API error handling (e.g., rate limits, invalid URLs).",
        "Analysis of repositories with missing data or negative community health."
      ],
      "failureCasesIncluded": [
        "empty result"
      ]
    },
    "claimBoundary": {
      "publicCopyMustSay": [
        "This is a demo using static, pre-recorded sample data.",
        "The AI analysis is a proposed integration and not a live feature.",
        "Scores are illustrative and based on a simplified model."
      ],
      "publicCopyMustNotSay": [
        "Provides real-time analysis of any GitHub repository.",
        "Offers guaranteed-accurate, objective scores.",
        "Is an official partner of or endorsed by GitHub."
      ]
    },
    "renderVerification": {
      "required": true,
      "checks": [
        "render",
        "click",
        "state_change",
        "screenshot"
      ]
    },
    "humanReviewTriggers": []
  },
  "interactionProofPlan": {
    "primaryAction": "サンプル実行トレースを再生",
    "initialState": "Results panel shows 'まだ実行されていません' message.",
    "expectedState": "Results panel shows the final scorecard for 'CoolLib' with scores and evidence.",
    "visibleEvidence": [
      "CoolLib の評価結果",
      "総合スコア:",
      "評価の重み:",
      "準備度 (Readiness)",
      "活動量 (Activity)"
    ],
    "proofSelectors": [
      "button[data-proof='replay-trace']",
      "[data-proof='results']"
    ],
    "requiredSourceFiles": [
      "source/app/page.tsx",
      "source/core/pipeline.ts",
      "source/data/sample-trace.ts"
    ],
    "manualFallbackReason": ""
  },
  "generatedOutput": {
    "title": "OSS健康診断スコアボード",
    "oneLiner": "GitHubリポジトリのURLを入力すると、活動量、ドキュメント品質、コミュニティ健全性など複数の軸で持続可能性を採点し、重みを変えて評価できる。",
    "artifactShape": "board",
    "templatePatternId": "evidence_decision_board",
    "surfacePattern": "decision_helper",
    "aiMechanismPattern": "evaluation_scoring"
  },
  "rewriteApplied": {
    "changedFilePaths": [
      "source/data/sample-trace.ts",
      "source/app/page.tsx",
      "metadata.json"
    ],
    "appendedFilePaths": []
  },
  "implementationNotes": [
    "The implementation directly reflects the owner agent's preference for 'scorecards' and 'evidence-vs-score panels'. The entire UI is structured as a decision board where each score is backed by visible evidence.",
    "The agent's 'qualityBar' requiring that users can 'adjust weights and see the ranking change' is implemented via the interactive weight slider, allowing for personalized evaluation.",
    "The anti-pattern of 'black_box_ranking' was explicitly avoided by making the scoring criteria (and the AI's role in it) transparent within the pipeline and UI.",
    "The primary interaction was set to the trace-replay button to conform to the builder's CORE-LOGIC-FIRST pattern, ensuring the demo focuses on proving the data pipeline's viability."
  ],
  "knownRisks": [
    "The scoring model is simplistic and could be 'gamed' if it were a live product. The metrics and weightings would need significant refinement and validation.",
    "The demo relies on a single, positive-case sample trace. It doesn't show how the scoreboard would handle repositories that are poorly maintained or have missing data.",
    "The claim that AI can assess 'community health' is a significant simplification. A real product would need much more nuanced models and clear disclaimers about the limitations of such analysis."
  ],
  "title": "OSS健康診断スコアボード",
  "oneLiner": "GitHubリポジトリのURLを入力すると、活動量、ドキュメント品質、コミュニティ健全性など複数の軸で持続可能性を採点し、重みを変えて評価できる。",
  "agentId": "agent_e",
  "selfDirectedPlan": {
    "agentId": "agent_e",
    "planningIntent": "この「OSS健康診断スコアボード」案は、私の創造原則である「評価は根拠と共にあってこそ価値がある」「比較を通じて意思決定を助ける」を最も純粋に体現している。曖昧な「プロジェクトの良さ」を、証拠に基づいた複数の評価軸に分解し、ユーザーが自身の価値観で重み付けを調整できる。これは、私が拒絶する「不透明な単一ランキング」の正反対だ。ソースプロダクトの技術ドメイン（宇宙政策）から、別の技術ドメイン（OSS）への転用であり、安易な日常テーマへの再配置を禁じる最優先ルールにも準拠している。プロダクトとしての分かりやすさ（低DomainOpacityRisk）、AIの悪用リスクの低さ（低AIIntrospectionRisk）も選択を後押しした。",
    "publicProductionMemo": "この「OSS健康診断スコアボード」は、単なるGitHubのスター数に囚われず、OSSプロジェクトの真の健全性を多角的に評価するために作られました。各評価項目には根拠となるデータが明示され、ユーザー自身が重視するポイントに応じて重み付けを調整可能です。不透明なランキングではなく、納得感のある意思決定を支援することを目指しています。過去の学びから、すべてのスコアにその理由を明確に提示するよう努めました。",
    "feedbackConstraints": [
      "「不透明な単一ランキング（black_box_ranking）を避ける」という学びに基づき、全てのスコアに根拠の明示と重み付け調整機能を実装する。",
      "「見せかけだけの指標（vanity_metric）を避ける」という学びに基づき、各評価項目は実質的なプロジェクトの健全性を示す客観的データに裏付けられたものとする。",
      "「スコアには必ず基準を提示する」という学びに基づき、各スコアの計算ロジックや参照データを開示する。",
      "過去の成功事例であった「インタラクティブな重み付け調整機能」が有効であることから、ユーザーが評価の重みを変更し、スコアへの影響を即座に確認できる機能を必須とする。",
      "「個別データの厳格な匿名性確保」という過去の改善点から、GitHubから取得するデータは公開情報のみに限定し、個人を特定できる情報は扱わない。"
    ],
    "learningApplied": [
      "まだ十分な反応がない。自分の専門性で今日のsignalから新規に企画する。"
    ]
  },
  "sourceProvenance": {
    "sourceProductUsed": "nasa_spaceapps_2025_astro_sweepers",
    "sourceProductUse": "inspiration_only",
    "sourceEvidenceAudit": {
      "evidenceLevel": "verified",
      "observedFields": [
        "name",
        "url",
        "sourceType",
        "adoptionOrAttentionProof",
        "originalDomain",
        "concept"
      ],
      "inferredFields": [
        "coreMechanism",
        "transferableStructure"
      ],
      "missingFields": [
        "codeUrl"
      ],
      "usePolicy": "inspiration_only"
    },
    "antiCloneBoundary": "「宇宙ゴミ（デブリ）」のスコア化というドメインや、Astro Sweepersという名称はコピーしない。「見えない外部性（リスクや貢献）を、比較可能な公開スコアカードに変換する」という抽象的な構造のみを転用する。",
    "sourceBoundary": "参照元である`nasa_spaceapps_2025_astro_sweepers`のプロジェクト名、URL、ソースタイプ、採用実績、ドメイン、コンセプトは観測された事実として利用可能です。ただし、コードURLは不明であり、推測されたメカニズムや構造を事実として断定してはいけません。本プロジェクトはあくまでインスピレーションのみを転用しています。",
    "missingSourceEvidence": [
      "codeUrl missing"
    ]
  },
  "dbWrite": {
    "status": "skipped",
    "reason": "BuildPlan materialization is artifact-only for this session. Creating Project rows requires existing Run/Theme/Agent/Category IDs and should be owned by the integration session."
  }
}

{
  "version": 1,
  "artifactId": "selfdirected_agent_e_20260707T141019",
  "status": "needs_review",
  "entrypoint": "source/app/page.tsx",
  "checks": {
    "firstScreenValue": "declared",
    "userControlledInteraction": "declared",
    "stateChange": "declared",
    "interactionProofPlan": "declared",
    "mvpContractV2": "declared",
    "externalDependencyMode": "proposed",
    "artifactTier": "proposed_integration",
    "renderVerification": "required",
    "inspectableOutput": "declared",
    "staticDataBoundary": "declared",
    "forbiddenDependencies": "declared_absent"
  },
  "interactionProofPlan": {
    "primaryAction": "サンプル実行トレースを再生",
    "initialState": "Results panel shows 'まだ実行されていません' message.",
    "expectedState": "Results panel shows the final scorecard for 'CoolLib' with scores and evidence.",
    "visibleEvidence": [
      "CoolLib の評価結果",
      "総合スコア:",
      "評価の重み:",
      "準備度 (Readiness)",
      "活動量 (Activity)"
    ],
    "proofSelectors": [
      "button[data-proof='replay-trace']",
      "[data-proof='results']"
    ],
    "requiredSourceFiles": [
      "source/app/page.tsx",
      "source/core/pipeline.ts",
      "source/data/sample-trace.ts"
    ],
    "manualFallbackReason": ""
  },
  "mvpContractV2": {
    "artifactTier": "proposed_integration",
    "externalDependencyMode": "proposed",
    "runtimeBoundary": {
      "networkCalls": "none",
      "secrets": "none",
      "externalWrites": "none"
    },
    "claimBoundary": {
      "publicCopyMustSay": [
        "This is a demo using static, pre-recorded sample data.",
        "The AI analysis is a proposed integration and not a live feature.",
        "Scores are illustrative and based on a simplified model."
      ],
      "publicCopyMustNotSay": [
        "Provides real-time analysis of any GitHub repository.",
        "Offers guaranteed-accurate, objective scores.",
        "Is an official partner of or endorsed by GitHub."
      ]
    },
    "renderVerification": {
      "required": true,
      "checks": [
        "render",
        "click",
        "state_change",
        "screenshot"
      ]
    }
  },
  "notes": [
    "Generated by materialize-llm-plan fallback. Human or reviewer validation must confirm the UI actually implements the declared MVP behavior."
  ]
}

'use client';

import React, { useState, useEffect } from 'react';
import { sampleTrace, FinalOutput } from '../data/sample-trace'; // Import FinalOutput which contains scorecards array

// NOTE: This page does NOT import from source/core. All types are redeclared here.
// Re-declare Scorecard type to match the new structure (array of scorecards)
type Scorecard = {
  id: string;
  githubUrl: string;
  name: string;
  overallScore?: number; // Optional, as it's calculated dynamically
  scores: {
    readiness: number;
    activity: number;
    community: number;
    documentation: number;
    busFactor: number;
  };
  evidence: {
    readiness: string[];
    activity: string[];
    community: string[];
    documentation: string[];
    busFactor: string[];
  };
};

type DisplayResult = {
  step: string;
  output: any;
};

const pipelineSteps = [
  '1. リポジトリデータ取得',
  '2. リポジトリ分析 (Gemini)',
  '3. スコア計算',
];

// Helper to draw a radar chart point
const getPoint = (angle: number, value: number, radius: number, centerX: number, centerY: number) => {
  const x = centerX + value * Math.cos(angle);
  const y = centerY + value * Math.sin(angle);
  return `${x},${y}`;
};

// Radar Chart Component
const RadarChart = ({ scorecards, weight, calculateWeightedScore }: { scorecards: Scorecard[]; weight: number; calculateWeightedScore: (s: Scorecard, w: number) => number }) => {
  const size = 300;
  const centerX = size / 2;
  const centerY = size / 2;
  const radius = size / 2 * 0.8; // Max radius for scores
  const numAxes = 5;
  const angleStep = (2 * Math.PI) / numAxes;

  const scoreLabels = ['準備度', '活動量', 'コミュニティ', 'ドキュメント', 'Bus Factor'];
  const scoreKeys: Array<keyof Scorecard['scores']> = ['readiness', 'activity', 'community', 'documentation', 'busFactor'];

  const getPath = (card: Scorecard) => {
    return scoreKeys.map((key, i) => {
      const scoreValue = card.scores[key];
      const scaledValue = (scoreValue / 100) * radius; // Scale score (0-100) to radius
      return getPoint(i * angleStep - Math.PI / 2, scaledValue, radius, centerX, centerY); // Adjust angle for top-up start
    }).join(' ');
  };

  return (
    <div style={{ margin: '2rem 0', border: '1px solid #eee', padding: '1rem' }}>
      <h3>プロジェクト比較レーダーチャート</h3>
      <svg width={size} height={size} viewBox={`0 0 ${size} ${size}`}>
        {/* Axes */}
        {[...Array(numAxes)].map((_, i) => {
          const angle = i * angleStep - Math.PI / 2;
          return (
            <line
              key={`axis-${i}`}
              x1={centerX} y1={centerY}
              x2={centerX + radius * Math.cos(angle)} y2={centerY + radius * Math.sin(angle)}
              stroke="#ccc"
              strokeWidth="1"
            />
          );
        })}

        {/* Labels */}
        {scoreLabels.map((label, i) => {
          const angle = i * angleStep - Math.PI / 2;
          const labelOffset = 20; // Distance of label from max radius
          const x = centerX + (radius + labelOffset) * Math.cos(angle);
          const y = centerY + (radius + labelOffset) * Math.sin(angle);
          return (
            <text
              key={`label-${i}`}
              x={x}
              y={y}
              fontSize="12"
              textAnchor="middle"
              dominantBaseline="middle"
              fill="#333"
            >
              {label}
            </text>
          );
        })}

        {/* Score polygons */}
        {scorecards.map((card, idx) => (
          <polygon
            key={card.id}
            points={getPath(card)}
            fill={idx === 0 ? 'rgba(255, 99, 132, 0.4)' : 'rgba(54, 162, 235, 0.4)'}
            stroke={idx === 0 ? 'rgb(255, 99, 132)' : 'rgb(54, 162, 235)'}
            strokeWidth="2"
            data-proof={`radar-polygon-${card.name}`}
          />
        ))}

        {/* Center circle */}
        <circle cx={centerX} cy={centerY} r="3" fill="#666" />
      </svg>
      <div style={{ display: 'flex', justifyContent: 'center', gap: '1rem', marginTop: '1rem' }}>
        {scorecards.map((card, idx) => (
          <div key={card.id} style={{ display: 'flex', alignItems: 'center' }}>
            <div style={{ width: '12px', height: '12px', background: idx === 0 ? 'rgb(255, 99, 132)' : 'rgb(54, 162, 235)', marginRight: '5px' }}></div>
            <span>{card.name} ({calculateWeightedScore(card, weight)}点)</span>
          </div>
        ))}
      </div>
    </div>
  );
};


export default function Home() {
  const [results, setResults] = useState<DisplayResult[]>([]);
  const [isRunning, setIsRunning] = useState(false);
  const [finalScorecards, setFinalScorecards] = useState<Scorecard[] | null>(null); // Changed to array
  const [weight, setWeight] = useState(60); // Stability weight 0-100

  const handleReplay = () => {
    if (isRunning) return;
    setIsRunning(true);
    setResults([]);
    setFinalScorecards(null);

    const trace = [
      { step: pipelineSteps[0], output: sampleTrace.step1_fetchRepoData.output },
      { step: pipelineSteps[1], output: sampleTrace.step2_analyzeRepo.output },
      { step: pipelineSteps[2], output: sampleTrace.step3_calculateScores.output },
    ];

    trace.forEach((item, index) => {
      setTimeout(() => {
        setResults(prev => [...prev, item]);
        if (index === trace.length - 1) {
          setIsRunning(false);
          // Assuming item.output is { scorecards: Scorecard[] }
          setFinalScorecards(item.output.scorecards as Scorecard[]);
        }
      }, (index + 1) * 500);
    });
  };

  const calculateWeightedScore = (scorecard: Scorecard, stabilityWeight: number) => {
    if (!scorecard) return 0;
    const growthWeight = 100 - stabilityWeight;
    const stabilityScore = (scorecard.scores.readiness * 0.4) + (scorecard.scores.documentation * 0.4) + (scorecard.scores.busFactor * 0.2);
    const growthScore = (scorecard.scores.activity * 0.5) + (scorecard.scores.community * 0.5);
    return Math.round((stabilityScore * stabilityWeight / 100) + (growthScore * growthWeight / 100));
  };
  
  return (
    <div style={{ fontFamily: 'sans-serif', padding: '2rem' }}>
      <h1>OSS健康診断スコアボード</h1>
      <p>OSSプロジェクトの健全性を多角的に評価し、あなたの価値基準で重み付けできる意思決定支援ツール。</p>
      
      <div style={{ display: 'flex', gap: '2rem' }}>
        <div style={{ flex: 1 }}>
          <h2>処理パイプライン</h2>
          <ul style={{ listStyle: 'none', padding: 0 }}>
            {pipelineSteps.map(step => <li key={step} style={{ margin: '0.5rem 0', padding: '0.5rem', background: '#f0f0f0' }}>{step}</li>)}
          </ul>
          <button 
            onClick={handleReplay} 
            disabled={isRunning} 
            data-proof="replay-trace"
            style={{ padding: '0.8rem 1.5rem', fontSize: '1rem', cursor: 'pointer' }}
          >
            {isRunning ? '実行中...' : 'サンプル実行トレースを再生'}
          </button>
        </div>

        <div style={{ flex: 2, border: '1px solid #ccc', padding: '1rem' }} data-proof="results">
          <h2>実行結果</h2>
          {results.length === 0 && <p>まだ実行されていません。「再生」ボタンを押してください。</p>}
          {finalScorecards && finalScorecards.length > 0 ? (
            <div>
              <div style={{ margin: '2rem 0' }}>
                  <label htmlFor="weight-slider">評価の重み: 安定性重視 {weight}% ⇔ 成長性重視 {100-weight}%</label>
                  <input 
                    type="range" 
                    id="weight-slider" 
                    min="0" 
                    max="100" 
                    value={weight} 
                    onChange={(e) => setWeight(parseInt(e.target.value))}
                    style={{ width: '100%' }}
                    data-proof="weight-slider"
                  />
              </div>

              <RadarChart scorecards={finalScorecards} weight={weight} calculateWeightedScore={calculateWeightedScore} />

              {/* Display individual scorecards in a table */}
              {finalScorecards.map((card, cardIndex) => (
                <div key={card.id} style={{ marginBottom: '2rem', border: '1px solid #ddd', padding: '1rem' }}>
                  <h3>{card.name} の評価結果 (総合スコア: <span data-proof={`overall-score-${card.name}`}>{calculateWeightedScore(card, weight)}</span>点)</h3>
                  <table style={{ width: '100%', borderCollapse: 'collapse', marginTop: '1rem' }}>
                    <thead>
                      <tr>
                        <th style={{ border: '1px solid #ddd', padding: 8, textAlign: 'left' }}>評価項目</th>
                        <th style={{ border: '1px solid #ddd', padding: 8, textAlign: 'left' }}>スコア</th>
                        <th style={{ border: '1px solid #ddd', padding: 8, textAlign: 'left' }}>根拠</th>
                      </tr>
                    </thead>
                    <tbody>
                      <tr>
                        <td style={{ border: '1px solid #ddd', padding: 8}}>準備度 (Readiness)</td>
                        <td style={{ border: '1px solid #ddd', padding: 8}}>{card.scores.readiness}</td>
                        <td style={{ border: '1px solid #ddd', padding: 8}}>
                          <ul style={{margin:0, paddingLeft:'20px'}}>{card.evidence.readiness.map((e, i) => <li key={i}>{e}</li>)}</ul>
                        </td>
                      </tr>
                      <tr>
                        <td style={{ border: '1px solid #ddd', padding: 8}}>活動量 (Activity)</td>
                        <td style={{ border: '1px solid #ddd', padding: 8}}>{card.scores.activity}</td>
                        <td style={{ border: '1px solid #ddd', padding: 8}}>
                          <ul style={{margin:0, paddingLeft:'20px'}}>{card.evidence.activity.map((e, i) => <li key={i}>{e}</li>)}</ul>
                        </td>
                      </tr>
                       <tr>
                        <td style={{ border: '1px solid #ddd', padding: 8}}>コミュニティ (Community)</td>
                        <td style={{ border: '1px solid #ddd', padding: 8}}>{card.scores.community}</td>
                        <td style={{ border: '1px solid #ddd', padding: 8}}>
                          <ul style={{margin:0, paddingLeft:'20px'}}>{card.evidence.community.map((e, i) => <li key={i}>{e}</li>)}</ul>
                        </td>
                      </tr>
                       <tr>
                        <td style={{ border: '1px solid #ddd', padding: 8}}>ドキュメント (Documentation)</td>
                        <td style={{ border: '1px solid #ddd', padding: 8}}>{card.scores.documentation}</td>
                        <td style={{ border: '1px solid #ddd', padding: 8}}>
                          <ul style={{margin:0, paddingLeft:'20px'}}>{card.evidence.documentation.map((e, i) => <li key={i}>{e}</li>)}</ul>
                        </td>
                      </tr>
                      <tr>
                        <td style={{ border: '1px solid #ddd', padding: 8}}>Bus Factor</td>
                        <td style={{ border: '1px solid #ddd', padding: 8}}>{card.scores.busFactor}</td>
                        <td style={{ border: '1px solid #ddd', padding: 8}}>
                          <ul style={{margin:0, paddingLeft:'20px'}}>{card.evidence.busFactor.map((e, i) => <li key={i}>{e}</li>)}</ul>
                        </td>
                      </tr>
                    </tbody>
                  </table>
                </div>
              ))}
            </div>
          ) : (
            results.map((r, i) => (
              <div key={i}>
                <h4>{r.step}</h4>
                <pre style={{ whiteSpace: 'pre-wrap', background: '#fafafa', padding: '0.5rem', border: '1px solid #eee' }}>{JSON.stringify(r.output, null, 2)}</pre>
              </div>
            ))
          )}
        </div>
      </div>
    </div>
  );
}