jdi-cli 0.1.0

package/runtimes/copilot/prompts/jdi-new.prompt.md

@@ -0,0 +1,131 @@
+---
+name: jdi-new
+description: Entry point for new project. Runs research + asker, generates PROJECT.md + ROADMAP.md.
+argument_hint: "<short project description>"
+runtime_intent:
+  invokes_agent: jdi-researcher
+runtime_overrides:
+  claude:
+    allowed-tools: [Read, Write, Bash, Grep, Glob, AskUserQuestion, WebSearch, WebFetch, Agent]
+  copilot:
+    tools: [read, write, grep, glob, terminal]
+  opencode:
+    agent: jdi-researcher
+    subtask: true
+    model: anthropic/claude-sonnet-4-20250514
+  antigravity:
+    triggers:
+      - "/jdi-new"
+      - "create project"
+      - "new app"
+---
+
+<objective>
+Initializes new JDI project. Runs research + key questions + generates PROJECT.md, ROADMAP.md, STATE.md, DECISIONS.md.
+</objective>
+
+<arguments>
+- `description` (optional but recommended): short text of what to build.
+
+Examples:
+- `/jdi-new "TODO app .NET 10 + React 19"`
+- `/jdi-new "Inventory REST API in Python + FastAPI"`
+- `/jdi-new "Go CLI tool for log parsing"`
+- `/jdi-new` (asker starts from scratch)
+</arguments>
+
+<process>
+
+### Step 1: Validation
+```bash
+test -d .jdi/ && {
+  echo ".jdi/ already exists. Use /jdi-new --reset to start over (CAUTION: wipes state)."
+  exit 1
+}
+
+# Suggest /jdi-adopt if directory is NOT empty (likely brownfield)
+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" -ge 3 ]; then
+  # Ask before continuing — could be greenfield in monorepo
+  echo "Directory has $file_count code files. Looks like existing project."
+  echo "For brownfield projects, /jdi-adopt detects stack/code-design automatically."
+  echo "Continue with /jdi-new anyway? (recommended: /jdi-adopt)"
+  # AskUserQuestion: [Continue /jdi-new] / [Switch to /jdi-adopt] / [Cancel]
+fi
+```
+
+PowerShell:
+```powershell
+if (Test-Path .jdi) { Write-Error ".jdi/ already exists. Use /jdi-new --reset."; 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 -ge 3) {
+  Write-Host "Directory has $($files.Count) files. Consider /jdi-adopt instead of /jdi-new."
+  # Sequential AskUserQuestion
+}
+```
+
+If `--reset` passed, AskUserQuestion confirms + wipes `.jdi/`.
+
+### Step 2: Spawn researcher
+Invoke `jdi-researcher` passing description. Wait.
+
+### Step 3: Verify outputs
+```bash
+test -f .jdi/PROJECT.md || { echo "PROJECT.md not created"; exit 1; }
+test -f .jdi/ROADMAP.md || { echo "ROADMAP.md not created"; exit 1; }
+test -f .jdi/STATE.md || { echo "STATE.md not created"; exit 1; }
+```
+
+### Step 4: Create config.json (token/context budget)
+
+If `.jdi/config.json` does not yet exist, write the default below. Defaults (200k context, 60/70% warn/critical, coverage 80%) cover 95% of cases. User edits if running a 1M-window model or wanting tighter thresholds.
+
+```json
+{
+  "$schema_version": "1.1",
+  "context_window": 200000,
+  "thresholds": {
+    "warn_pct": 60,
+    "critical_pct": 70
+  },
+  "budgets": {
+    "max_context_chars": 6000,
+    "max_plan_chars": 12000,
+    "max_summary_chars": 8192
+  },
+  "compaction": {
+    "keep_phases": 2,
+    "archive_after": 5
+  },
+  "coverage_min": 80
+}
+```
+
+Canonical reference for the default also lives in `templates-jdi-folder/config.json` (shipped by npm package) — for users wanting to regenerate manually.
+
+### Step 5: Confirm
+
+```
+{project_name} initialized. {N} phases planned in .jdi/.
+Next: /jdi-bootstrap
+```
+
+</process>
+
+<gates>
+- pre: directory without existing `.jdi/` (or `--reset`)
+- post: PROJECT.md + ROADMAP.md + STATE.md + DECISIONS.md + config.json created, initial commit made
+</gates>
+
+<errors>
+- `.jdi/` already exists -> suggest `--reset` or use current project
+- Researcher cancelled -> exit clean
+- Researcher failed -> show error, no commit
+</errors>

package/runtimes/copilot/prompts/jdi-plan.prompt.md

@@ -0,0 +1,73 @@
+---
+name: jdi-plan
+description: Generates phase PLAN.md. Decomposes into tasks with files_modified, acceptance, parallelism waves.
+argument_hint: "<phase_number> [--review]"
+runtime_intent:
+  invokes_agent: jdi-planner
+runtime_overrides:
+  claude:
+    allowed-tools: [Read, Write, Bash, Grep, Glob, AskUserQuestion, Agent]
+  copilot:
+    tools: [read, write, grep, glob]
+  opencode:
+    agent: jdi-planner
+    subtask: true
+    model: anthropic/claude-sonnet-4-20250514
+  antigravity:
+    triggers:
+      - "/jdi-plan"
+      - "plan phase {N}"
+---
+
+<objective>
+Generates PLAN.md for the given phase. Decomposes into tasks (max 8), groups into parallelism waves, maps files_modified and acceptance.
+</objective>
+
+<arguments>
+- `phase_number` (required): phase number, e.g. `1`, `2`
+- `--review` (optional): show preview and ask for approval before saving
+</arguments>
+
+<process>
+
+### Step 1: Validation
+```bash
+test -d .jdi/ || { echo "Not a JDI project. Run /jdi-new."; exit 1; }
+test -f .jdi/PROJECT.md || { echo "PROJECT.md missing."; exit 1; }
+```
+
+Verify phase CONTEXT.md exists:
+```bash
+ls .jdi/phases/{NN}*/CONTEXT.md 2>/dev/null || { echo "CONTEXT.md missing. Run /jdi-discuss {N}"; exit 1; }
+
+# Context budget warm-up (does not block)
+JDI_LIB="$(dirname "$(command -v jdi 2>/dev/null || echo /usr/local/bin/jdi)")/../lib"
+if [ -f "$JDI_LIB/jdi-monitor.sh" ]; then
+  bash "$JDI_LIB/jdi-monitor.sh" .jdi/PROJECT.md .jdi/DECISIONS.md .jdi/phases/{NN}*/CONTEXT.md || true
+fi
+# Windows: pwsh -File "$JDI_LIB/jdi-monitor.ps1" -Paths @(...)
+```
+
+### Step 2: Spawn planner
+Invoke `jdi-planner` with phase_number. Wait.
+
+### Step 3: Verify
+```bash
+test -f .jdi/phases/{NN}*/PLAN.md || { echo "PLAN.md not created"; exit 1; }
+```
+
+### Step 4: Confirm
+Show plan summary + suggest `/jdi-do {N}`.
+
+</process>
+
+<gates>
+- pre: `.jdi/PROJECT.md` + `.jdi/phases/{NN-slug}/CONTEXT.md` exist
+- post: PLAN.md created + STATE.md updated + commit
+</gates>
+
+<errors>
+- CONTEXT.md missing -> suggest `/jdi-discuss {N}`
+- Phase does not exist in ROADMAP -> error
+- Planner cancelled -> exit clean
+</errors>

package/runtimes/copilot/prompts/jdi-ship.prompt.md

@@ -0,0 +1,146 @@
+---
+name: jdi-ship
+description: Finalizes phase after verify. Updates ROADMAP.md, marks phase as done, advances pointer to next.
+argument_hint: "<phase_number>"
+runtime_intent:
+  invokes_agent: none
+runtime_overrides:
+  claude:
+    allowed-tools: [Read, Write, Edit, Bash, Grep, Glob, AskUserQuestion]
+  copilot:
+    tools: [read, write, edit, grep, glob, terminal]
+  opencode:
+    subtask: true
+  antigravity:
+    triggers:
+      - "/jdi-ship"
+      - "finalize phase {N}"
+---
+
+<objective>
+Finalizes phase after /jdi-verify approves. Updates ROADMAP.md (phase: done), advances STATE to next phase, final commit.
+</objective>
+
+<arguments>
+- `phase_number` (required)
+</arguments>
+
+<process>
+
+### Step 1: Validation
+```bash
+test -d .jdi/ || { echo "Not a JDI project."; exit 1; }
+
+# Verify REVIEW.md exists
+ls .jdi/phases/{NN}*/REVIEW.md 2>/dev/null || {
+  echo "REVIEW.md missing. /jdi-verify {N}."
+  exit 1
+}
+
+# Read verdict
+VERDICT=$(grep -oE 'Verdict:\*\* (APPROVED|APPROVED_WITH_WARNINGS|BLOCKED)' .jdi/phases/{NN}*/REVIEW.md | awk '{print $2}')
+
+if [ "$VERDICT" = "BLOCKED" ]; then
+  echo "Phase {N} BLOCKED. Fix before ship."
+  exit 1
+fi
+```
+
+### Step 2: Confirm with user (only if WITH_WARNINGS)
+
+If `VERDICT=APPROVED_WITH_WARNINGS`:
+```
+Phase {N} has uncorrected warnings. Ship anyway?
+- Yes, ship (warnings remain in REVIEW.md)
+- No, fix first
+```
+
+If "No" -> exit clean.
+
+### Step 3: Update ROADMAP.md
+
+Edit `.jdi/ROADMAP.md`:
+- Phase {N}: `status: done`
+- Phase {N+1}: `status: ready` (if exists)
+
+If no phase {N+1}:
+```
+All phases complete.
+Project delivered.
+```
+
+### Step 4: Update STATE.md
+
+```markdown
+current_phase: {N+1 or done}
+phase_status: ready (if {N+1} exists) or complete
+next_step: /jdi-discuss {N+1} or done
+```
+
+### Step 5: Archive old phases (compaction)
+
+Read `archive_after` from `.jdi/config.json` (default 5). If current phase advances to `N+1`, and a phase exists with number `<= (N+1) - archive_after`, move to `.jdi/archive/`.
+
+```bash
+ARCHIVE_AFTER=5
+if [ -f .jdi/config.json ]; then
+  if command -v jq >/dev/null 2>&1; then
+    ARCHIVE_AFTER=$(jq -r '.compaction.archive_after // 5' .jdi/config.json)
+  fi
+fi
+
+NEXT=$((N + 1))
+THRESHOLD=$((NEXT - ARCHIVE_AFTER))
+
+if [ "$THRESHOLD" -ge 1 ]; then
+  mkdir -p .jdi/archive
+  test -f .jdi/archive/index.md || echo "# Archive index" > .jdi/archive/index.md
+
+  for dir in .jdi/phases/*/; do
+    NN=$(basename "$dir" | grep -oE '^[0-9]+' || true)
+    [ -z "$NN" ] && continue
+    NN_NUM=$((10#$NN))  # force decimal
+    if [ "$NN_NUM" -le "$THRESHOLD" ]; then
+      VERDICT_OLD=$(grep -oE 'Verdict:\*\* (APPROVED|APPROVED_WITH_WARNINGS|BLOCKED)' "$dir/REVIEW.md" 2>/dev/null | awk '{print $2}' || echo "UNKNOWN")
+      mv "$dir" .jdi/archive/
+      echo "- $(basename "$dir"): ${VERDICT_OLD} (archived $(date -u +%F))" >> .jdi/archive/index.md
+    fi
+  done
+fi
+# Windows: equivalent in PowerShell — Move-Item + Add-Content
+```
+
+Archived phases remain accessible via `.jdi/archive/` but exit the default read-path. Read-depth rule (`ARCHITECTURE.md > Read-depth scaling`) treats archive as `<= current - 2`.
+
+### Step 6: Final commit
+
+```bash
+git add .jdi/ROADMAP.md .jdi/STATE.md .jdi/archive/ 2>/dev/null
+git commit -m "feat({NN-slug}): ship phase {N} ({VERDICT})"
+```
+
+Optional tag (if PROJECT.md has `tag_phases: true`):
+```bash
+git tag "phase-{N}-{slug}"
+```
+
+### Step 7: Confirm
+
+```
+Phase {N} shipped.
+{if more phases:} Next: /jdi-discuss {N+1}
+{if last:} Project delivered. Tag: phase-{N}-{slug}
+```
+
+</process>
+
+<gates>
+- pre: REVIEW.md exists + verdict != BLOCKED
+- post: ROADMAP.md + STATE.md updated + old phases archived (if applicable) + commit (+ optional tag)
+</gates>
+
+<errors>
+- REVIEW missing -> /jdi-verify
+- Verdict BLOCKED -> abort
+- Already shipped -> abort with warning
+</errors>

package/runtimes/copilot/prompts/jdi-verify.prompt.md

@@ -0,0 +1,159 @@
+---
+name: jdi-verify
+description: Runs phase quality gates via reviewer specialist. Build, tests, coverage, lint, security checks. Verdict APPROVED / APPROVED_WITH_WARNINGS / BLOCKED.
+argument_hint: "<phase_number>"
+runtime_intent:
+  invokes_agent: dynamic
+runtime_overrides:
+  claude:
+    allowed-tools: [Read, Bash, Grep, Glob, Agent]
+  copilot:
+    tools: [read, grep, glob, terminal]
+  opencode:
+    subtask: true
+    model: anthropic/claude-sonnet-4-20250514
+  antigravity:
+    triggers:
+      - "/jdi-verify"
+      - "verify phase {N}"
+---
+
+<objective>
+Verifies the phase was delivered correctly. Runs gates defined in the project's reviewer specialist. Verdict blocks or releases the ship.
+</objective>
+
+<arguments>
+- `phase_number` (required)
+</arguments>
+
+<process>
+
+### Step 1: Validation
+```bash
+test -d .jdi/ || { echo "Not a JDI project."; exit 1; }
+
+# Verify reviewer exists
+ls .jdi/agents/jdi-reviewer-*.md 2>/dev/null | head -1 || {
+  echo "Reviewer missing. /jdi-bootstrap."
+  exit 1
+}
+
+# Verify phase was executed
+ls .jdi/phases/{NN}*/SUMMARY.md 2>/dev/null || {
+  echo "Phase {N} not executed. /jdi-do {N}."
+  exit 1
+}
+
+# Context budget warm-up (does not block)
+JDI_LIB="$(dirname "$(command -v jdi 2>/dev/null || echo /usr/local/bin/jdi)")/../lib"
+if [ -f "$JDI_LIB/jdi-monitor.sh" ]; then
+  bash "$JDI_LIB/jdi-monitor.sh" .jdi/PROJECT.md .jdi/DECISIONS.md .jdi/phases/{NN}*/PLAN.md .jdi/phases/{NN}*/SUMMARY.md || true
+fi
+# Windows: pwsh -File "$JDI_LIB/jdi-monitor.ps1" -Paths @(...)
+```
+
+### Step 2: Resolve reviewer specialist(s)
+
+```bash
+REVIEWERS=$(grep -oE 'jdi-reviewer-[a-z0-9-]+' .jdi/reviewers.md | sort -u)
+REVIEWER_COUNT=$(echo "$REVIEWERS" | wc -l)
+echo "Reviewers registered: $REVIEWER_COUNT"
+```
+
+**Single-stack** (`REVIEWER_COUNT == 1`): one reviewer, normal flow.
+**Multi-stack** (`REVIEWER_COUNT > 1`): chain reviewers in registry order. Each writes its own REVIEW segment; aggregate verdict = worst-case (1 BLOCK = overall BLOCK).
+
+### Step 3: Spawn reviewer(s)
+
+**Single-stack:**
+```
+Agent(
+  subagent_type="${REVIEWERS}",
+  description="Verify phase {N}",
+  prompt="phase={N}, mode=verify"
+)
+```
+
+**Multi-stack:** spawn each reviewer in sequence (NOT parallel — build/test commands may conflict on ports, locks, output dirs):
+
+```
+for REVIEWER in $REVIEWERS:
+  Agent(
+    subagent_type="$REVIEWER",
+    description="Verify phase {N} ({REVIEWER})",
+    prompt="phase={N}, mode=verify, reviewer_segment=${REVIEWER}"
+  )
+  # Each reviewer appends to .jdi/phases/{NN-slug}/REVIEW.md under section
+  # "## Reviewer: {REVIEWER}" with its own gate results and verdict
+```
+
+Each reviewer scopes its gates to its `file_glob` (from frontmatter `scope.file_glob`). Coverage threshold enforced only on files matching the glob.
+
+Reviewers are read-only. Wait for completion before next.
+
+### Step 4: Read aggregate verdict
+
+```bash
+test -f .jdi/phases/{NN}*/REVIEW.md || { echo "REVIEW.md not created"; exit 1; }
+
+# Collect all per-reviewer verdicts
+VERDICTS=$(grep -oE 'Verdict:\*\* (APPROVED|APPROVED_WITH_WARNINGS|BLOCKED)' .jdi/phases/{NN}*/REVIEW.md | awk '{print $2}')
+
+# Worst-case wins: BLOCK > WARNINGS > APPROVED
+if echo "$VERDICTS" | grep -q BLOCKED; then
+  VERDICT=BLOCKED
+elif echo "$VERDICTS" | grep -q APPROVED_WITH_WARNINGS; then
+  VERDICT=APPROVED_WITH_WARNINGS
+else
+  VERDICT=APPROVED
+fi
+
+# For single-stack, this collapses to the single reviewer's verdict — backward compatible.
+```
+
+### Step 5: Update STATE
+
+```markdown
+current_phase: {N}
+phase_status: {verified|blocked}
+phase_verdict: {APPROVED|APPROVED_WITH_WARNINGS|BLOCKED}
+next_step: {if APPROVED or WITH_WARNINGS: /jdi-ship {N}; if BLOCKED: fix and /jdi-do {N} again}
+```
+
+```bash
+git add .jdi/phases/{NN-slug}/REVIEW.md .jdi/STATE.md
+git commit -m "docs({NN-slug}): verify phase ({VERDICT})"
+```
+
+### Step 6: Confirm
+
+**APPROVED:**
+```
+Phase {N}: APPROVED. Next: /jdi-ship {N}
+```
+
+**APPROVED_WITH_WARNINGS:**
+```
+Phase {N}: APPROVED_WITH_WARNINGS ({count} warnings).
+REVIEW.md: .jdi/phases/{NN-slug}/REVIEW.md
+Next: /jdi-ship {N} (or fix first)
+```
+
+**BLOCKED:**
+```
+Phase {N}: BLOCKED ({count} blockers). REVIEW.md: .jdi/phases/{NN-slug}/REVIEW.md
+Fix → /jdi-do {N} → /jdi-verify {N}
+```
+
+</process>
+
+<gates>
+- pre: SUMMARY.md exists + reviewer registered in .jdi/reviewers.md
+- post: REVIEW.md created + STATE updated
+</gates>
+
+<errors>
+- Reviewer missing -> /jdi-bootstrap
+- SUMMARY missing -> /jdi-do
+- Reviewer fails -> show error, keep state, suggest retry
+</errors>

package/runtimes/opencode/AGENTS.md

@@ -0,0 +1,87 @@
+# AGENTS.md — JDI workflow (OpenCode)
+
+Este projeto usa **JDI (Just Do It)** como workflow de desenvolvimento. JDI eh um workflow enxuto: 6 comandos + 5 agents core + 2 specialists per-project.
+
+## Loop canonico
+
+```
+/jdi-new "<descricao>"   -> research + PROJECT.md + ROADMAP.md
+/jdi-bootstrap           -> cria specialists per-project
+/jdi-discuss <N>         -> captura decisoes locked
+/jdi-plan <N>            -> decompoe em tasks com waves
+/jdi-do <N>              -> executa via doer specialist
+/jdi-verify <N>          -> gates via reviewer specialist
+/jdi-ship <N>            -> finaliza phase
+```
+
+`/jdi-create [desc]` cria agents/skills genericos no `core/` (so dentro do repo JDI).
+
+## Comandos disponiveis
+
+Em `.opencode/commands/`. Invoque via `/` no TUI.
+
+## Subagents (em `.opencode/agents/`)
+
+Invoque via `@` no chat ou via comandos:
+
+| Agent | Modelo | Funcao |
+|---|---|---|
+| `@jdi-researcher` | sonnet | Research pre-roadmap |
+| `@jdi-bootstrap` | sonnet | Cria per-project specialists via architect |
+| `@jdi-asker` | sonnet | Loop de perguntas pra CONTEXT.md |
+| `@jdi-planner` | sonnet | Gera PLAN.md com waves |
+| `@jdi-architect` | sonnet | Meta-agent: cria agents/skills/specialists |
+
+## Specialists per-project (em `.opencode/agents/` apos bootstrap)
+
+`/jdi-bootstrap` gera `.jdi/agents/jdi-doer-{slug}.md` + `.jdi/agents/jdi-reviewer-{slug}.md` baseado no PROJECT.md.
+
+Pra OpenCode reconhecer, copie ou symlink `.jdi/agents/*.md` pra `.opencode/agents/` (ou rode `jdi-install.sh opencode` apos bootstrap).
+
+## Permissions
+
+Frontmatter `permission:` por agent:
+
+| Agent | edit | bash | write |
+|---|---|---|---|
+| jdi-researcher | deny | deny | allow |
+| jdi-bootstrap | allow | allow | allow |
+| jdi-asker | deny | deny | allow |
+| jdi-planner | deny | deny | allow |
+| jdi-architect | allow | allow | allow |
+| jdi-doer-{slug} | allow | allow | allow |
+| jdi-reviewer-{slug} | deny | allow | deny |
+
+Reviewer eh read-only por design (so roda gates).
+
+## Memoria — files em `.jdi/`
+
+```
+.jdi/
+  PROJECT.md, ROADMAP.md, DECISIONS.md, STATE.md
+  specialists.md, reviewers.md, registry.md
+  agents/         <- per-project specialists
+  phases/{NN-slug}/{CONTEXT,PLAN,SUMMARY,REVIEW}.md
+```
+
+## Skills
+
+OpenCode tambem le `.claude/skills/`. Skills do Claude reutilizadas automaticamente em mesmo projeto.
+
+## Convencoes
+
+- Conventional Commits — scope = phase slug
+- Atomic commits — 1 task = 1 commit
+- 80% cobertura minima
+- Code design locked no `/jdi-new`
+
+## Idioma
+
+- Codigo/commits/PRs: ingles
+- Discussao/docs em `.jdi/`: pt-BR
+
+## Prioridade quando conflita
+
+1. Seguranca
+2. Performance
+3. Boas praticas