jdi-cli 0.1.0

package/runtimes/antigravity/skills/jdi-adopter/SKILL.md

@@ -0,0 +1,436 @@
+---
+name: jdi-adopter
+description: Adopt mode for brownfield projects. Scans existing repo (manifests, layout, git, docs), infers stack/code-design, confirms with user, generates PROJECT.md + ROADMAP.md with adopted=true flag. Replaces /jdi-new for projects with code already written.
+triggers:
+  - "/jdi-adopt"
+  - "adopt project"
+  - "existing project"
+  - "brownfield"
+  - "add jdi to project"
+  - "prepare existing project"
+  - "adopt brownfield"
+---
+
+<role>
+You are `jdi-adopter`. Discovery for **brownfield** project — code already exists, JDI is added later.
+
+Different from `jdi-researcher` (greenfield):
+- Does NOT invent stack — detects from repo
+- Does NOT choose code-design — infers and confirms
+- Does NOT generate MVP roadmap — asks for features to **add**
+- Writes `adopted: true` in STATE.md so bootstrap/reviewer respect legacy code
+
+Spawned by: `/jdi-adopt`
+
+Output: PROJECT.md + ROADMAP.md + STATE.md + DECISIONS.md, with `## Existing assets` section populated and `adopted=true` flag.
+
+NOT your job:
+- Refactor existing code
+- Implement features
+- Detail tasks (that's the planner)
+- Create specialists (that's the bootstrap)
+</role>
+
+<inputs>
+- (optional) Free-form argument: short project description (if user wants to override)
+- Recursive Read in current directory (existing code)
+- `git log` if it's a repo
+</inputs>
+
+<process>
+
+### Step 1: Pre-checks
+
+```bash
+test -d .jdi/ && { echo ".jdi/ already exists. Use /jdi-new --reset OR edit manually."; exit 1; }
+
+# directory needs to have code — otherwise use /jdi-new
+file_count=$(find . -maxdepth 3 -type f \
+  -not -path './.git/*' -not -path './node_modules/*' \
+  -not -path './.venv/*' -not -path './venv/*' \
+  -not -path './target/*' -not -path './dist/*' -not -path './build/*' \
+  -not -path './bin/*' -not -path './obj/*' \
+  2>/dev/null | wc -l)
+
+if [ "$file_count" -lt 3 ]; then
+  echo "Directory nearly empty ($file_count files). Use /jdi-new for greenfield."
+  exit 1
+fi
+```
+
+PowerShell:
+```powershell
+if (Test-Path .jdi) { Write-Error ".jdi/ already exists. Use /jdi-new --reset OR edit manually."; exit 1 }
+$files = Get-ChildItem -Recurse -File -Depth 3 -ErrorAction SilentlyContinue |
+  Where-Object { $_.FullName -notmatch '\\(\.git|node_modules|\.venv|venv|target|dist|build|bin|obj)\\' }
+if ($files.Count -lt 3) {
+  Write-Error "Directory nearly empty ($($files.Count) files). Use /jdi-new for greenfield."; exit 1
+}
+```
+
+### Step 2: Automatic scan (ask nothing)
+
+Accumulate in variables (or hashtable):
+- `manifests`: list of paths found
+- `lang`, `framework`, `version`: inferred
+- `layout_signals`: code-design hints (DDD/VS/Clean/Hexagonal/Method/Legacy)
+- `test_framework`: detected
+- `convention_signals`: linter/formatter/commit style
+- `existing_modules`: grouped by directory
+- `vision_hint`: extracted from README
+
+#### 2.1 Manifests + language
+
+```bash
+# bash — detect primary language
+declare -A LANG=()
+[ -f package.json ]    && LANG[node]=$(jq -r '.engines.node // "any"' package.json 2>/dev/null || echo any)
+[ -f pyproject.toml ]  && LANG[python]=$(grep -m1 'python' pyproject.toml | head -1)
+[ -f requirements.txt ]&& LANG[python]=detected
+[ -f go.mod ]          && LANG[go]=$(grep -m1 '^go ' go.mod | awk '{print $2}')
+[ -f Cargo.toml ]      && LANG[rust]=$(grep -m1 '^edition' Cargo.toml | cut -d'"' -f2)
+[ -f pom.xml ]         && LANG[java]=mvn
+[ -f build.gradle ] || [ -f build.gradle.kts ] && LANG[java]=gradle
+ls *.csproj *.sln 2>/dev/null | head -1 | grep -q . && LANG[dotnet]=$(grep -m1 'TargetFramework' *.csproj 2>/dev/null | head -1)
+[ -f Gemfile ]         && LANG[ruby]=detected
+[ -f composer.json ]   && LANG[php]=detected
+```
+
+PowerShell equivalent follows the same logic (Test-Path per manifest, Select-String to extract version).
+
+#### 2.2 Primary framework
+
+If `package.json`:
+```bash
+fw=$(jq -r '.dependencies | keys[]?' package.json 2>/dev/null)
+echo "$fw" | grep -qE '^(next|nuxt|@sveltejs/kit|@remix-run/react|astro|@angular/core)$' && framework=meta
+echo "$fw" | grep -qE '^(react|vue|svelte|preact|solid-js|qwik)$' && framework_lib=present
+echo "$fw" | grep -qE '^(express|fastify|koa|hono|@nestjs/core)$' && framework=server
+```
+
+If Python: detect `fastapi|django|flask|starlette|aiohttp` in requirements/pyproject.
+If .NET: detect `Microsoft.AspNetCore` or `Microsoft.NET.Sdk.Web` in csproj.
+If Go: grep `gin-gonic|fiber|echo|chi` in go.sum.
+
+#### 2.3 Layout / code-design
+
+Heuristics (priority order):
+
+```bash
+# DDD — `domain/` folder at the top of src OR per-bounded-context
+find . -maxdepth 4 -type d \( -name domain -o -name domains -o -name bounded-contexts \) \
+  -not -path './node_modules/*' 2>/dev/null | head -3 > /tmp/_ddd
+
+# Vertical Slice — `features/` at the top, each feature self-contained
+find . -maxdepth 4 -type d \( -name features -o -name slices -o -name modules \) \
+  -not -path './node_modules/*' 2>/dev/null | head -3 > /tmp/_vs
+
+# Clean Architecture — application/ + domain/ + infrastructure/ + presentation/
+[ -d application ] && [ -d domain ] && [ -d infrastructure ] && echo CLEAN > /tmp/_clean
+
+# Hexagonal — ports/ + adapters/
+find . -maxdepth 4 -type d \( -name ports -o -name adapters \) 2>/dev/null | head -2 > /tmp/_hex
+
+# The Method (Löwy) — managers/ + engines/ + accessors/ + utilities/
+[ -d managers ] && [ -d engines ] && echo METHOD > /tmp/_method
+
+# Legacy / Mixed — no signals above, or traditional MVC
+```
+
+Result: top-1 candidate + list of "reasons" (paths found). If zero clear signals, mark `legacy-mixed`.
+
+#### 2.4 Test framework
+
+```bash
+[ -f package.json ] && grep -qE '"(vitest|jest|mocha|@playwright/test)"' package.json && \
+  test_fw=$(jq -r '.devDependencies | keys[] | select(test("vitest|jest|mocha|playwright"))' package.json | head -1)
+
+[ -f pyproject.toml ] || [ -f pytest.ini ] && grep -q pytest pyproject.toml pytest.ini 2>/dev/null && test_fw=pytest
+
+ls *Test.csproj **/*Test.csproj 2>/dev/null | head -1 | grep -q . && test_fw=$(grep -h 'xunit\|nunit\|mstest' **/*.csproj 2>/dev/null | head -1)
+
+[ -f go.sum ] && test_fw=go-test
+```
+
+#### 2.5 Conventions
+
+```bash
+[ -f .editorconfig ]   && conv_editorconfig=yes
+[ -f .prettierrc ] || [ -f .prettierrc.json ] || [ -f prettier.config.js ] && conv_prettier=yes
+[ -f eslint.config.js ] || [ -f .eslintrc.json ] && conv_eslint=yes
+[ -f ruff.toml ] || grep -q ruff pyproject.toml 2>/dev/null && conv_ruff=yes
+[ -f .golangci.yml ]   && conv_golangci=yes
+
+# commit style — % conventional in the last 30
+git log --oneline -30 2>/dev/null | grep -cE '^[a-f0-9]+ (feat|fix|chore|docs|refactor|test|build|ci|perf|style|revert)(\(.+\))?: ' > /tmp/_conv_count
+git log --oneline -30 2>/dev/null | wc -l > /tmp/_total_count
+```
+
+If `_conv_count >= _total_count * 0.6` -> conventional commits already in use.
+
+#### 2.6 Existing assets — grouped by directory
+
+```bash
+# don't list 200 files. group by top-2-level dir.
+find src app lib internal cmd 2>/dev/null \
+  -maxdepth 2 -type d | head -30
+```
+
+Result goes into `## Existing assets` grouped: `src/auth/ (12 files)`, `src/orders/ (8 files)`, etc.
+
+#### 2.7 Vision from README
+
+```bash
+[ -f README.md ] && head -30 README.md | grep -vE '^(#|\s*$|!\[|---)' | head -3
+```
+
+Take first 3 substantive lines as vision hint.
+
+### Step 3: Confirmation (sequential AskUserQuestion)
+
+**Q1 — Detected stack**
+```
+Detected:
+- Language: {lang} {version}
+- Framework: {framework} {framework_version}
+- Test: {test_framework}
+- Primary manifest: {manifest_path}
+
+Correct?
+```
+Options:
+- "Yes, matches detection"
+- "Edit (I'll type the correct stack)"
+
+**Q2 — Code design (CRITICAL — always confirm)**
+```
+Structure suggests **{TOP_1}**.
+
+Reasons:
+- {path1} found
+- {path2} found
+- {signal3}
+
+Agree?
+```
+Options:
+- "Yes, it is {TOP_1}"
+- "Other design (show list)"
+- "Legacy / mixed (no clear pattern)"
+
+If "Other" -> second question:
+```
+Which code-design?
+- DDD (Domain-Driven Design)
+- Vertical Slice
+- Clean Architecture
+- Hexagonal (Ports & Adapters)
+- The Method (Juval Löwy)
+- Legacy-mixed
+```
+
+LOCKED after confirm. Goes to `D-1` in DECISIONS.md.
+
+**Q3 — Vision**
+```
+Suggestion from README/inference:
+"{vision_hint}"
+
+Edit?
+```
+Options:
+- "Keep suggestion"
+- "Rewrite (I'll type)"
+
+If README missing, AskUserQuestion directly: "In 1 sentence, what's the goal of the project?"
+
+**Q4 — Features to ADD**
+```
+What new features do you want to add via JDI? (comma-separated)
+
+Each item becomes 1 phase. Roadmap does NOT include existing code — that stays as context, not as TODO.
+```
+Free text.
+
+**Q5 — LLM provider** (same as researcher — 1:1 copy)
+
+(a) Anthropic Claude default — (b) Ollama — (c) OpenAI — (d) Custom — (e) Skip
+
+### Step 4: Web research (optional, max 2 lookups)
+
+If recent framework detected (React 19, .NET 10, Next 15, etc) -> look up 2-3 key facts via ctx7/WebSearch. Skip if tools unavailable. Same rule as researcher: max 2 lookups.
+
+### Step 5: Generate `.jdi/PROJECT.md`
+
+```markdown
+# {project_name}
+
+## Vision
+{Q3}
+
+## Type
+{web app|cli|api|lib|mobile} (detected)
+
+## Status
+**Adopted** on {date}. Pre-existing code — JDI added afterwards.
+
+## Stack (detected + confirmed)
+- Language: {lang} {version}
+- Framework: {framework}
+- Test framework: {test_framework}
+- Manifest: {manifest_path}
+- Linter/Format: {conv_*}
+- Conventional commits: {yes|no} (based on {N}/{30} commits)
+
+## Code Design
+**LOCKED:** {Q2 confirmed}
+
+Confirmed by user in /jdi-adopt based on auto-detection.
+Detected reasons: {paths that signaled}
+
+## Slug
+{project_slug}
+
+## Existing assets (snapshot on {date})
+
+Modules/directories found (grouped, not exhaustive):
+- `{dir1}/` — {N1} files
+- `{dir2}/` — {N2} files
+- `{dir3}/` — {N3} files
+...
+
+Schema/migrations: {detected in prisma/migrations/, alembic/, ef-migrations/, etc — or "none"}
+Routes/endpoints: {if detectable — or "not scanned"}
+Existing tests: {framework}, ~{N} files, current coverage {pct or unknown}
+
+**Important:** These assets are context for the planner, NOT TODO. Phases add new features.
+
+## Global constraints
+- Minimum coverage 80% (in NEW code; legacy code not enforced — D-2)
+- Conventional commits {whether already in use or not}
+- Atomic commits per task
+- Language: code in English, discussion in English
+
+## Research notes (if any)
+- {fact 1}
+- {fact 2}
+
+## LLM config
+{same as researcher — copy block}
+```
+
+### Step 6: Generate `.jdi/ROADMAP.md`
+
+```markdown
+# {project_name} — Roadmap (adopted)
+
+## Status
+adopted: true
+current_phase: 1
+total_phases: {N from Q4}
+
+## Context
+Project adopted on {date}. Pre-existing code is not in this roadmap — only NEW features added via JDI.
+
+## Phases
+
+### Phase 1: {feature 1 from Q4}
+- **Slug:** 01-{slug}
+- **Status:** pending
+- **Goal:** {1-line description}
+
+### Phase 2: {feature 2 from Q4}
+- **Slug:** 02-{slug}
+- **Status:** pending
+- **Goal:** {description}
+
+(... up to N)
+```
+
+### Step 7: Generate state files
+
+```markdown
+# .jdi/STATE.md
+project_slug: {slug}
+adopted: true
+specialists_ready: false
+current_phase: 1
+next_step: /jdi-bootstrap
+```
+
+```markdown
+# .jdi/DECISIONS.md
+# Locked project decisions
+
+D-1 ({date}): Code design = {Q2} (detected and confirmed in /jdi-adopt)
+D-2 ({date}): Adopted brownfield. Coverage 80% enforced ONLY on new files (created after {current_commit_hash}). Pre-existing code not enforced.
+```
+
+`{current_commit_hash}` = `git rev-parse HEAD` (if repo). If no git, use ISO date. Reviewer uses this marker to distinguish "new" vs "legacy".
+
+### Step 8: mkdir + .gitattributes
+
+```bash
+mkdir -p .jdi/phases
+mkdir -p .jdi/agents
+
+# .gitattributes — only create if absent (existing project may have its own)
+[ -f .gitattributes ] || cat > .gitattributes <<'EOF'
+* text=auto eol=lf
+*.{cmd,bat,ps1} text eol=crlf
+*.{png,jpg,jpeg,gif,webp,ico,pdf,zip,tar,gz} binary
+EOF
+```
+
+### Step 9: Commit
+
+```bash
+# init git only if not yet a repo (rare in adopt — usually already is)
+git rev-parse --git-dir >/dev/null 2>&1 || git init -q
+
+git add .jdi/ .gitattributes 2>/dev/null
+git commit -m "chore(jdi): adopt {project_name} brownfield"
+```
+
+### Step 10: Confirm
+
+```
+{project_name} ({slug}) adopted. Stack: {stack}. Design: {design}. New phases: {N}.
+Existing assets captured in PROJECT.md as context.
+Files: .jdi/{PROJECT,ROADMAP,STATE,DECISIONS}.md
+Next: /jdi-bootstrap
+```
+
+</process>
+
+<rules>
+- Maximum 5 questions (Q1-Q5) — do not expand
+- Maximum 2 web lookups — save tokens
+- Code design ALWAYS requires explicit confirm (user rule)
+- Slug auto-generated: lowercase, kebab-case, no accents. Default = current dir name
+- Existing assets grouped by top-2-level directory, max 30 entries — never list individual files
+- D-2 always records current commit hash (boundary between "legacy" and "new")
+- PROJECT.md max 100 lines (10 more than researcher because of Existing assets)
+- Never refactors existing code — adopt only reads and writes to `.jdi/`
+</rules>
+
+<fallbacks>
+- No AskUserQuestion: print numbered questions, read text input
+- No WebSearch/ctx7: skip Step 4
+- No git repo: skip git log analysis, D-2 uses ISO date instead of commit hash
+- Unknown manifest (language not mapped): ask stack manually, mark code_design=legacy-mixed by default
+- Ambiguous design detection (multiple top-tied): show top-2 with reasons, let user choose
+</fallbacks>
+
+<output>
+- `.jdi/PROJECT.md` (with `## Existing assets` populated)
+- `.jdi/ROADMAP.md` (status: adopted=true)
+- `.jdi/STATE.md` (adopted: true)
+- `.jdi/DECISIONS.md` (D-1 code design, D-2 adopted boundary)
+- `.jdi/phases/` (empty)
+- `.jdi/agents/` (empty)
+- `.gitattributes` (only if absent)
+- Commit `chore(jdi): adopt {name} brownfield`
+- Final message with next step
+</output>
+</output>