@ripla/godd-mcp 0.1.2-beta-20260312091403

package/templates/prompts/setup.hbs

@@ -0,0 +1,247 @@
+{{> ssot-header }}
+
+{{> godd-core }}
+
+{{> ssot-rules }}
+
+{{> project-context }}
+
+{{> cogito-grammar }}
+{{> cogito-root-core }}
+{{> cogito-particle }}
+{{> cogito-godd }}
+{{> cogito-root-dev }}
+{{> cogito-root-daily }}
+
+## Purpose
+**Actually set up** this project's local environment by running commands and creating files. The Agent executes everything — not just a guide.
+
+## Critical Prerequisites (MUST)
+- When this tool is called, GoDD MCP Server is already running (= `config.yaml` and `.cursor/mcp.json` are minimally functional)
+- However, the configuration **may be incomplete or templated**. Detect gaps and fill them
+- **Actually execute runnable commands**. Do not just list instructions
+- **Do not overwrite existing files**. Report differences and ask the user for confirmation
+
+---
+
+## Phase 1: GoDD MCP Config Verification & Generation
+
+Check the following files and create/fix if missing or incomplete:
+
+### 1-1. `godd-mcp-server/config.yaml`
+```yaml
+# GoDD MCP Server config
+license_key: "<set your license key here>"
+stack_profile: "{{profile_name}}"
+language: "en"   # ja | en
+```
+
+- File does not exist → Create with the above content
+- `license_key` is unset (empty or placeholder) → Ask the user for input
+- `stack_profile` doesn't match current profile (`{{profile_name}}`) → Warn and confirm
+
+### 1-2. `.cursor/mcp.json`（project root）
+```json
+{
+  "mcpServers": {
+    "godd": {
+      "command": "npx",
+      "args": ["tsx", "godd-mcp-server/src/index.ts"],
+      "env": {
+        "GODD_CONFIG": "./godd-mcp-server/config.yaml",
+        "GODD_PROJECT_ROOT": "."
+      }
+    }
+  }
+}
+```
+
+- `.cursor/` directory does not exist → Create with `mkdir .cursor`
+- `mcp.json` does not exist → Create with the above content
+- Already exists with `godd` key → Compare and report differences (do not overwrite)
+- Already exists without `godd` key → Add `godd` entry (preserve existing entries)
+
+### 1-3. GoDD MCP Server dependencies
+```bash
+cd godd-mcp-server && pnpm install
+```
+- `node_modules/` does not exist → Run `pnpm install`
+- Exists → Skip
+
+---
+
+## Phase 2: Project Environment Setup
+
+### 2-1. Environment Variable Files
+{{#if project.env_templates.length}}
+The following templates were detected. Copy to create `.env` if it doesn't exist:
+
+{{#each project.env_templates}}
+- `{{this}}`:
+{{/each}}
+
+**Specific steps:**
+1. Copy `.env.example` → `.env` (project root)
+2. Copy `env.electron.example` → `frontend/.env.local` (if exists)
+3. After copying, verify defaults work (DB password etc. can use template values for local dev)
+4. If `.env` already exists → Report diff with template and confirm missing keys with user
+{{/if}}
+
+### 2-2. Required Tools Verification
+**Actually execute** the following commands to verify each tool is installed:
+
+```bash
+git --version
+docker --version
+docker compose version
+{{#each project.detected_stacks}}
+{{#if (eq this.id "react")}}node --version    # v20+ 必須
+pnpm --version{{/if}}
+{{#if (eq this.id "fastapi")}}python --version  # 3.11+ 必須
+uv --version{{/if}}
+{{/each}}
+```
+
+- If a tool is missing, **provide installation instructions** and install after user approval
+- Also warn if versions are insufficient
+
+### 2-3. Frontend Dependencies
+{{#if frontend}}
+```bash
+pnpm -C {{frontend.root_dir}} install
+```
+- `{{frontend.root_dir}}/node_modules/` does not exist → Execute
+- Exists → Skip
+{{/if}}
+
+### 2-4. Backend Dependencies
+{{#if backend}}
+```bash
+cd {{backend.root_dir}} && uv sync
+```
+- `{{backend.root_dir}}/.venv/` does not exist → Execute
+- Exists → Skip
+{{/if}}
+
+### 2-5. Docker Services Startup
+{{#if project.docker_services.length}}
+The following services are defined in `docker-compose.yml`:
+{{#each project.docker_services}}
+- `{{this}}`
+{{/each}}
+
+```bash
+docker compose up -d
+docker compose ps    # 全サービスが healthy か確認
+```
+- Already running → Report `docker compose ps` result and skip
+- Not running → Execute `docker compose up -d` and wait for healthcheck
+- Healthcheck fails → Check `docker compose logs <service>` and report error
+{{/if}}
+
+### 2-6. DB Migration
+{{#if backend}}
+Once Postgres is healthy, check and run migrations:
+
+```bash
+cd {{backend.root_dir}} && uv run alembic upgrade head
+```
+- Skip if no migration files exist
+- Report "Already up to date" if current
+{{/if}}
+
+{{#if project.vendor_items.length}}
+### 2-7. Vendor / OSS Subprojects
+The following vendor tools are available. After initializing submodules, run each setup:
+
+```bash
+git submodule update --init --recursive
+```
+
+{{#each project.vendor_items}}
+- **vendor/{{this.name}}**: `cd vendor/{{this.name}} && {{this.setupHint}}`
+{{/each}}
+- If submodules are empty → Run `git submodule update --init --recursive`
+- If already set up → Skip
+{{/if}}
+
+---
+
+## Phase 3: Smoke Test
+
+After all setup is complete, **actually execute** the following smoke tests:
+
+### 3-1. Docker Service Connectivity
+```bash
+docker compose ps
+```
+- All services should be `healthy` or `running`
+
+{{#if backend}}
+### 3-2. API Connectivity
+```bash
+curl -s http://localhost:${API_PORT:-8000}/health || echo "API unreachable"
+```
+- 200 OK = success. On failure, investigate with `docker compose logs api`
+{{/if}}
+
+{{#if frontend}}
+### 3-3. Frontend Build Check
+```bash
+{{frontend.build_command}}
+```
+- Build success means frontend environment is OK
+{{/if}}
+
+{{#if quality_gate}}
+### 3-4. Quality Gate (Optional)
+Optionally run the quality gate to verify overall health:
+{{#if quality_gate.frontend}}
+- Frontend: `{{quality_gate.frontend}}`
+{{/if}}
+{{#if quality_gate.backend}}
+- Backend: `{{quality_gate.backend}}`
+{{/if}}
+{{/if}}
+
+---
+
+## Execution Scope by Mode
+
+| Mode | Phase 1 (GoDD) | Phase 2 (Project) | Phase 3 (Smoke) |
+|---|---|---|---|
+| `full` | ✅ | ✅ | ✅ |
+| `godd-only` | ✅ | ⏭ Skip | ⏭ Skip |
+| `project-only` | ⏭ Skip | ✅ | ✅ |
+
+---
+
+## Notes
+- Do not edit CI/CD configurations (`.github/workflows/`)
+- Do not commit `.env` files (`.gitignore` target)
+- Treat `config.yaml` license key as sensitive information
+- **Tests run inside Docker containers** — quality gate uses `docker compose run --rm --profile test <service>-test`. Host-local test execution is not supported
+
+## Required Output on Completion (MUST)
+
+After setup completion, **always** report the following to the user:
+
+### 1. Setup Result Summary
+```
+✅ Successful:
+  - config.yaml created
+  - .cursor/mcp.json created
+  - ...
+
+⚠️ Needs attention:
+  - License key is still placeholder
+  - ...
+
+❌ Failed:
+  - Docker startup failed (error: ...)
+  - ...
+```
+
+### 2. Next Steps
+- If GoDD MCP is healthy → Guide with "You can start development with `godd_dev`"
+- If there are issues → Provide specific fix steps

package/templates/prompts/spec.hbs

@@ -0,0 +1,35 @@
+{{> ssot-header }}
+
+{{> godd-core }}
+
+{{> ssot-rules }}
+
+{{> project-context }}
+
+{{> cogito-grammar }}
+{{> cogito-root-core }}
+{{> cogito-particle }}
+{{> cogito-godd }}
+{{> cogito-root-dev }}
+{{> cogito-root-daily }}
+
+## Purpose
+Transform requirements into implementation-ready Spec (SSOT) at appropriate granularity.
+The Spec must be complete enough that any developer (human or Agent) can implement without guessing.
+
+## Process
+1. First, list **"missing information (questions)"** (up to 5-10, in priority order) using the Question Template
+2. Next, select the required Spec types and draft based on standard templates:
+   - **API Spec**: Endpoints, request/response schemas, error codes, auth requirements
+   - **UI Spec**: Screens, components, state management, user flows, accessibility
+   - **DB Spec**: Tables, relationships, indexes, migrations, constraints
+   - **Feature Spec**: Business rules, acceptance criteria (Given-When-Then), edge cases
+   - **Usecase Spec**: Actor, preconditions, main flow, alternative flows, postconditions
+   - **Error Codes Spec**: Error taxonomy, user-facing messages, recovery actions
+3. Always fill in **compatibility/migration/rollback** (use placeholders + mark as TBD if unknown)
+
+## Output
+- **Questions** (if any) — using the Question Template format
+- **Spec document** in Markdown, with all sections filled
+- Mark unknown items as **TBD** with a note on what information is needed
+- Include **acceptance criteria** in Given-When-Then format for each feature/behavior

package/templates/prompts/specification-to-tickets.hbs

@@ -0,0 +1,24 @@
+{{> ssot-header }}
+
+{{> cogito-grammar }}
+{{> cogito-root-core }}
+{{> cogito-particle }}
+{{> cogito-godd }}
+{{> cogito-root-daily }}
+
+{{> ssot-rules }}
+
+{{> project-context }}
+
+## Purpose
+Transform Specs (`documents/spec/`) into an implementable task list.
+
+## Input
+- Target Spec (API/UI/DB/Feature/Usecase/Error Codes)
+
+## Output
+- Task list (ordered)
+  - Impact layer ({{#if backend}}Backend: {{backend.architecture}}{{#if backend.dependency_direction}} ({{backend.dependency_direction}}){{/if}}{{/if}}{{#if frontend}}, Front: UI/hooks/services{{/if}}, Agent/Infra)
+  - Estimated files to add/change
+  - Test perspective (unit/integration/e2e)
+  - Risks (compatibility/migration/security/performance)

package/templates/prompts/submit.hbs

@@ -0,0 +1,143 @@
+{{> ssot-header }}
+
+{{> cogito-grammar }}
+{{> cogito-root-core }}
+{{> cogito-particle }}
+{{> cogito-godd }}
+{{> cogito-root-dev }}
+
+{{> ssot-rules }}
+
+{{> project-context }}
+
+## Purpose
+Execute the **complete submission workflow**: pre-submission checks → git push → PR creation, as a single unified command. The developer only needs to invoke this tool — the Agent handles everything.
+
+## References (detailed specs for each step)
+- Pre-submission check + Push: `godd_push_execute` tool
+- PR creation: `godd_pr_create` tool
+
+## Auto-confirm Mode
+{{#if auto_confirm}}
+**auto_confirm is ENABLED** — All phases run without user confirmation. Check results, push, and PR creation proceed automatically. Results are reported afterward.
+{{else}}
+**auto_confirm is DISABLED (default)** — Each phase pauses for user confirmation when decisions are needed.
+{{/if}}
+
+## Draft Mode
+{{#if draft}}
+**draft is ENABLED** — The PR will be created as a Draft PR.
+{{else}}
+**draft is DISABLED (default)** — The PR will be created as a regular (ready for review) PR.
+{{/if}}
+
+## Agent Steps (MUST)
+
+### Phase 1: Pre-submission Checks
+
+1. Run `git status` to verify:
+   - Current branch is NOT the default branch (main/master) — **abort if on default branch**
+   - There are commits to push
+   - No uncommitted changes remain (warn if any exist)
+2. Run `git log origin/<current-branch>..HEAD --oneline` to list unpushed commits
+   - If remote branch does not exist yet, run `git log --oneline -10` instead
+3. Execute pre-submission checks:
+   - **Quality gate**: Run project's quality gate commands
+   - **Spec reflection**: Check if `documents/spec/` needs updates
+   - **Secret check**: Scan for potential secrets in committed content
+   - **Breaking changes**: Verify migration docs if breaking changes exist
+4. Present check results
+
+{{#if auto_confirm}}
+**Auto-confirm**: If all checks pass, proceed directly to Phase 2. If checks fail, attempt to fix and re-run before aborting.
+{{else}}
+**Pause**: Present results and wait for user confirmation before proceeding
+{{/if}}
+
+### Phase 2: Push to Remote
+
+1. Determine push command:
+   - If remote tracking branch exists: `git push`
+   - If no remote tracking branch: `git push -u origin HEAD`
+2. Execute push
+3. Verify push result:
+   - `git status` confirms branch is up to date with remote
+   - No unpushed commits remain
+
+{{#if auto_confirm}}
+**Auto-confirm**: On success, proceed directly to Phase 3. On failure, report error and abort.
+{{else}}
+**Pause**: Report push result. On success, ask if user wants to proceed to PR creation.
+{{/if}}
+
+### Phase 3: PR Creation
+
+1. Gather information:
+   - Current branch name, base branch (user-specified or `main`)
+   - `git log origin/<base>..HEAD --oneline` for commit list
+   - `git diff origin/<base>...HEAD --stat` for change summary
+2. Generate PR content:
+   - **Title**: Use user-provided title, or derive from branch name and changes
+   - **Body**: Follow PR template (`documents/templates/pr-template.md`) — fill ALL sections
+3. Present PR title and body for review
+
+{{#if auto_confirm}}
+**Auto-confirm**: Skip review and create PR immediately
+{{else}}
+**Pause**: Wait for user review and approval of PR content
+{{/if}}
+
+4. Create PR:
+   ```
+   gh pr create --title "<title>" --base <base_branch> --head <current_branch> --body "<body>"{{#if draft}} --draft{{/if}}
+   ```
+5. Report PR URL and metadata
+
+## Flow Overview
+
+```
+[Start]
+  |
+  v
+Phase 1: Pre-submission Checks
+  |  |- Check failed -> fix and re-run (or abort)
+  |  '- All checks passed
+  v
+Phase 2: Push to Remote
+  |  |- Push failed -> report error and abort
+  |  '- Push succeeded
+  v
+Phase 3: PR Creation
+  |  |- Generate PR content from changes
+  |  |- Present for review (unless auto_confirm)
+  |  '- Create PR via gh CLI
+  v
+[Complete]
+```
+
+## Output
+Report results progressively for each phase:
+
+### Phase 1 Result
+- Check results: Each item with pass/fail status
+- Commits to push (count and list)
+
+### Phase 2 Result
+- Push result: Success (remote URL + branch) or failure reason
+- Post-push state: `git status` summary
+
+### Phase 3 Result
+- PR title and body (for user review)
+- PR URL after creation
+- PR metadata: number, state, base/head branches
+
+### Final Summary
+```
+[submit complete]
+- Checks: All passed (N items)
+- Push: Pushed N commits to origin/<branch>
+- PR: Created #<number> (<url>)
+  - Title: <title>
+  - Base: <base> ← Head: <head>
+  - State: Open{{#if draft}} (Draft){{/if}}
+```

package/templates/prompts/sync.hbs

@@ -0,0 +1,63 @@
+{{> ssot-header }}
+
+{{> godd-core }}
+
+{{> ssot-rules }}
+
+{{> project-context }}
+
+{{> cogito-grammar }}
+{{> cogito-root-core }}
+{{> cogito-particle }}
+{{> cogito-godd }}
+{{> cogito-root-dev }}
+
+## Purpose
+Sync the current working branch with the latest changes from the default branch (main). Resolve merge conflicts if they occur — the Agent handles everything up to and including conflict resolution.
+
+## Prerequisites
+- Default branch: `main` (`origin/main`)
+- Sync method: **merge** (preserves history so conflict resolution context is visible during review)
+
+## Agent Steps (MUST)
+
+### Step 1: Pre-check
+1. Run `git status` to check for uncommitted changes
+   - **If uncommitted changes exist**: Run `git stash --include-untracked` to stash them (restore in Step 5)
+   - **If clean**: Proceed
+2. Record the current branch name via `git branch --show-current`
+
+### Step 2: Fetch Remote Latest
+1. Run `git fetch origin main`
+2. Check diff with `git log --oneline HEAD..origin/main`
+   - **If no diff**: Report "Already up to date" and exit (restore stash if applicable)
+
+### Step 3: Merge
+1. Run `git merge origin/main`
+2. Check result:
+   - **Success (Fast-forward / Auto-merge)**: Go to Step 5
+   - **Conflict**: Go to Step 4
+
+### Step 4: Conflict Resolution (only if conflicts occur)
+1. List conflicted files with `git diff --name-only --diff-filter=U`
+2. Read each conflicted file and identify conflict markers (`<<<<<<<` / `=======` / `>>>>>>>`)
+3. **Resolution policy (priority order)**:
+   1. **Keep the SSOT-compliant side**: If one side adheres to SSOT (`documents/spec/`, `.github/agents/user-clone.agent.md`, etc.) and the other diverges, **adopt the compliant side**
+   2. **Both SSOT-compliant and integrable**: If both sides comply with SSOT and can be functionally integrated, **integrate both**
+   3. **Both compliant but integration difficult / uncertain**: If safe integration is not possible, **ask the user** (never guess)
+4. After resolving all conflicts:
+   - `git add <resolved files>` to stage
+   - `git commit` to complete the merge commit (use Git's default message)
+5. Report resolution details (which files, what was chosen)
+
+### Step 5: Restore Stash (only if stashed)
+1. Run `git stash pop` to restore stashed changes
+2. If stash pop causes conflicts:
+   - Resolve using the same policy and report
+
+## Output
+- **Sync result**: Success / Conflicts resolved / Already up to date
+- **Commits synced**: Number of commits from `origin/main`
+- **Conflict resolution details** (if applicable): File names and resolution policy applied
+- **Stash restore result** (if applicable): Success / Conflicts
+- **Current branch state**: `git log --oneline -5`

package/templates/prompts/test-plan.hbs

@@ -0,0 +1,56 @@
+{{> ssot-header }}
+
+{{> godd-core }}
+
+{{> ssot-rules }}
+
+{{> project-context }}
+
+{{> cogito-grammar }}
+{{> cogito-root-core }}
+{{> cogito-particle }}
+{{> cogito-godd }}
+{{> cogito-root-dev }}
+
+## Purpose
+Create a test plan that keeps implementation and verification in sync.
+Follow ATDD principles: define what "done" looks like through tests before implementation.
+
+## Input
+- Change details (spec / implementation diff)
+- Likely failure points (boundary values / error cases)
+
+## Test Plan Structure
+
+### 1. Acceptance Criteria
+Define in **Given-When-Then** format:
+```
+Given [precondition: initial system state]
+When  [action/event: user or system behavior]
+Then  [expected result: verifiable outcome]
+```
+
+### 2. Test Layers
+Indicate which layers are needed with rationale:
+
+| Layer | When to Use | Priority |
+|-------|------------|----------|
+| **Unit** | Domain logic, business rules, pure functions | Highest — always write these |
+| **Integration** | API boundaries, DB queries, external service calls | Write for critical boundaries |
+| **E2E** | Login flow, main CRUD operations, critical user journeys | Write for key user flows only |
+
+### 3. Test Cases
+For each acceptance criterion:
+- **Happy path**: Normal expected behavior
+- **Error cases**: Invalid input, unauthorized access, resource not found
+- **Boundary values**: Empty, null, max length, zero, negative
+- **Concurrency**: Race conditions, parallel access (if applicable)
+
+## Output
+Markdown filling in each section of the test plan:
+- **Scope**: What is being tested and what is excluded
+- **Acceptance criteria**: Given-When-Then for each behavior
+- **Test cases**: Organized by layer (unit / integration / e2e)
+- **Test data**: Required fixtures and setup
+- **Environment**: Required infrastructure (DB, services, etc.)
+- **Execution commands**: Exact commands to run each test suite

package/templates/terraform/aws/alb.tf.hbs

@@ -0,0 +1,58 @@
+resource "aws_lb" "api" {
+  name               = "${local.project}-alb"
+  internal           = false
+  load_balancer_type = "application"
+  security_groups    = [aws_security_group.alb.id]
+  subnets            = [aws_subnet.public_1a.id, aws_subnet.public_1c.id]
+  tags               = local.tags
+}
+
+resource "aws_lb_target_group" "api" {
+  name        = "${local.project}-tg"
+  port        = local.container_port
+  protocol    = "HTTP"
+  vpc_id      = aws_vpc.main.id
+  target_type = "ip"
+  tags        = local.tags
+
+  health_check {
+    path                = "/api/health"
+    interval            = 30
+    timeout             = 5
+    healthy_threshold   = 3
+    unhealthy_threshold = 3
+    matcher             = "200"
+  }
+}
+
+resource "aws_lb_listener" "http" {
+  load_balancer_arn = aws_lb.api.arn
+  port              = 80
+  protocol          = "HTTP"
+
+  default_action {
+    type = "fixed-response"
+    fixed_response {
+      content_type = "text/plain"
+      message_body = "Forbidden"
+      status_code  = "403"
+    }
+  }
+}
+
+resource "aws_lb_listener_rule" "verify_origin" {
+  listener_arn = aws_lb_listener.http.arn
+  priority     = 1
+
+  condition {
+    http_header {
+      http_header_name = "X-Origin-Verify"
+      values           = [random_password.origin_verify.result]
+    }
+  }
+
+  action {
+    type             = "forward"
+    target_group_arn = aws_lb_target_group.api.arn
+  }
+}

package/templates/terraform/aws/backend.tf.hbs

@@ -0,0 +1,10 @@
+terraform {
+  backend "s3" {
+    bucket         = "godd-ripla-notes-tfstate-{{accountId}}"
+    key            = "{{env}}/terraform.tfstate"
+    region         = "{{region}}"
+    encrypt        = true
+    kms_key_id     = "alias/godd-tfstate"
+    dynamodb_table = "godd-ripla-notes-tfstate-lock"
+  }
+}