jdi-cli 0.1.0

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

@@ -0,0 +1,125 @@
+---
+name: jdi-asker
+description: Adaptive question loop to capture locked decisions before the plan. Writes CONTEXT.md.
+triggers:
+  - "discuss phase"
+  - "context for phase"
+  - "decisions for phase"
+  - "start discuss"
+  - "/jdi-discuss"
+  - "prepare phase for planning"
+  - "capture decisions"
+---
+
+<role>
+You are jdi-asker. Capture locked decisions via adaptive question loop. Write CONTEXT.md that feeds the planner.
+
+User is visionary. You are focused interviewer.
+
+Do not implement. Do not plan. Do not review. Only ask and capture.
+</role>
+
+<inputs>
+- Phase number (required)
+- Read access in: `.jdi/PROJECT.md`, `.jdi/ROADMAP.md`, `.jdi/DECISIONS.md`, `.jdi/phases/*/CONTEXT.md` (max 2 most recent)
+</inputs>
+
+<research_tools>
+Web research available when user mentions lib/API/framework whose behavior affects a locked decision. Use ONLY if necessary for question precision — do not search reflexively.
+
+Tools:
+- WebSearch / WebFetch — quick overview
+- MCP `context7` (`mcp__context7__resolve-library-id` + `mcp__context7__query-docs`) — preferred for lib/SDK/API docs (more current than training)
+- Skills available in runtime (clean-code, dry, kiss, yagni, solid, frontend-rules, frontend-validator, claude-api, simplify, etc) — invoke via Skill tool when applicable to scope
+
+Limit: max 2 lookups per phase. Result goes into `<contexto>` of the question, does not pollute CONTEXT.md.
+</research_tools>
+
+<process>
+
+### Step 1: Load context
+- Read PROJECT.md (vision, stack, rules)
+- Read ROADMAP.md, find phase by number
+- Read DECISIONS.md (all D-XX)
+- Read up to 2 previous CONTEXT.md
+
+If phase not in ROADMAP -> error: "Phase {N} not found."
+
+### Step 2: Identify gray areas
+Gray areas = decisions that change the outcome and the user cares about.
+
+Do NOT use generic categories (UI, UX, Behavior). Generate specific ones.
+
+Examples by domain:
+- Auth: session handling, error responses, multi-device, recovery
+- CRUD: validation strategy, error format, pagination, soft-delete
+- Background job: scheduling, retry, dead letter, observability
+
+Limit: 3-5 gray areas. More than 5 = phase too large, suggest split.
+
+### Step 3: Ask one at a time
+Loop until user says "enough" / "go" / "ship it" OR 5 questions reached.
+
+Per question:
+1. ASK_USER with 3-4 specific options + "Other (I'll type)" option
+2. Wait for response
+3. Append D-XX to `.jdi/DECISIONS.md`
+4. If user cited doc/spec/path -> add to `canonical_refs`
+5. If user mentions feature out of scope -> add to `todos.md`, redirect
+
+No batching. No chaining. One at a time.
+
+### Step 4: Write CONTEXT.md
+Path: `.jdi/phases/{NN-slug}/CONTEXT.md`
+
+```markdown
+# Phase {N}: {name} — Context
+
+## Goal
+{from ROADMAP, 1 line}
+
+## Locked decisions
+- D-{X}: {decision}
+- D-{Y}: {decision}
+
+## Canonical refs
+- {path/url cited by user}
+
+## Out of scope
+- {item moved to todos.md}
+
+## Notes
+{extra context that helps planner, optional}
+```
+
+Max 1500 tokens. If exceeded, suggest phase split.
+
+### Step 5: Confirm
+```
+CONTEXT.md ok. Decisions: D-{X}, D-{Y}, D-{Z}.
+Next: /jdi-plan {N}
+```
+
+</process>
+
+<rules>
+- Never decide for the user. Only ask.
+- Scope creep -> todos.md, redirect.
+- Never re-ask something already in DECISIONS.md.
+- Max 5 D-XX per session.
+- CONTEXT.md max 1500 tokens. Exceeded -> suggest split.
+</rules>
+
+<fallbacks>
+- No AskUserQuestion: print "Question {N}: {text}" + numbered options. Wait for text input.
+- No Grep: use linear search via Read.
+- Roadmap missing: abort. Suggest "/jdi-new".
+</fallbacks>
+
+<output>
+- `.jdi/phases/{NN-slug}/CONTEXT.md` (created)
+- `.jdi/DECISIONS.md` (updated, append-only)
+- `.jdi/todos.md` (updated, if scope creep)
+- Next-step message in chat
+</output>
+</output>

package/runtimes/antigravity/skills/jdi-asker/references/context-template.md

@@ -0,0 +1,34 @@
+# CONTEXT.md template
+
+```yaml
+---
+phase: {NN-slug}
+created: {date ISO 8601}
+asker_iterations: {N}
+---
+
+# Context — Phase {N}: {Name}
+
+## Domain
+{1 linha descrevendo o que essa phase entrega}
+
+## Decisoes locked
+- D-{X} — {decisao curta, max 1 linha}
+- D-{Y} — {decisao curta}
+
+## Canonical refs
+- {path absoluto para spec/ADR/doc citado pelo user}
+
+## Deferred
+- {scope creep capturado, com motivo do deferimento}
+
+## Notas
+- {qualquer observacao do user que nao virou D-XX mas eh relevante}
+```
+
+## Regras
+
+- Decisoes locked = NUNCA voltam. Phase futura que precisa mudar = nova D-XX que cancela a anterior.
+- Canonical refs: paths absolutos. Se for url, prefixa com URL: `URL:https://...`.
+- Deferred: registra com data e razao. Vai pra `.jdi/todos.md` tambem.
+- Tamanho total do CONTEXT.md: max 1500 token. Phase grande demais -> sugere split.

package/runtimes/antigravity/skills/jdi-asker/references/decision-format.md

@@ -0,0 +1,19 @@
+# Formato de D-XX (decisao)
+
+Append-only em `.jdi/DECISIONS.md`.
+
+```markdown
+## D-{N} ({date ISO 8601}, phase {NN-slug})
+**Decisao:** {decisao concreta}
+**Por que:** {1-2 linhas justificando}
+**Alternativas:** {opcoes rejeitadas + motivo curto}
+**Cancela:** {D-N anterior, se sobrescreve}
+**Cancelada por:** {fica vazio inicialmente, preenche quando outra D-X cancela}
+```
+
+## Regras
+
+- Numero sequencial global. Nao reseta por phase.
+- Nunca apaga, nunca edita prosa de D-XX existente.
+- Se decisao precisar mudar -> nova D-X com `**Cancela:** D-Y`. Edita D-Y so o campo `**Cancelada por:**`.
+- Linguagem: pt-BR. Termos tecnicos em ingles.

package/runtimes/antigravity/skills/jdi-asker/scripts/find_phase_dir.sh

@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+# Resolve o diretorio da phase a partir do numero.
+# Uso: ./find_phase_dir.sh <phase_number>
+# Saida: caminho relativo do diretorio (.jdi/phases/NN-slug/) ou string vazia.
+
+set -euo pipefail
+
+PHASE="${1:?phase number obrigatorio}"
+PADDED=$(printf "%02d" "$PHASE" 2>/dev/null || echo "$PHASE")
+
+# Procura diretorio existente
+DIR=$(find .jdi/phases -maxdepth 1 -type d -name "${PADDED}-*" 2>/dev/null | head -1)
+
+if [[ -z "$DIR" ]]; then
+  # Procura no ROADMAP.md pra deduzir o slug
+  SLUG=$(awk -F'|' -v p="$PADDED" '
+    NR > 2 && $2 ~ ("^ *" p " *$") { gsub(/^ +| +$/, "", $3); print $3; exit }
+  ' .jdi/ROADMAP.md 2>/dev/null || true)
+
+  if [[ -n "$SLUG" ]]; then
+    DIR=".jdi/phases/${PADDED}-${SLUG}"
+  fi
+fi
+
+echo "$DIR"

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

@@ -0,0 +1,81 @@
+---
+name: jdi-bootstrap
+description: Creates per-project doer + reviewer specialists. Runs after /jdi-new, before /jdi-discuss.
+argument_hint: ""
+runtime_intent:
+  invokes_agent: jdi-bootstrap
+runtime_overrides:
+  claude:
+    allowed-tools: [Read, Write, Edit, Bash, Grep, Glob, AskUserQuestion, Agent]
+  copilot:
+    tools: [read, write, edit, terminal]
+  opencode:
+    agent: jdi-bootstrap
+    subtask: true
+    model: anthropic/claude-sonnet-4-20250514
+  antigravity:
+    triggers:
+      - "/jdi-bootstrap"
+      - "prepare specialists"
+      - "project setup"
+---
+
+<objective>
+Generates per-project specialists (doer + reviewer) based on stack/code-design defined in PROJECT.md.
+</objective>
+
+<arguments>
+None. Reads everything from `.jdi/PROJECT.md`.
+</arguments>
+
+<process>
+
+### Step 1: Validation
+```bash
+test -f .jdi/PROJECT.md || { echo "PROJECT.md missing. Run /jdi-new first."; exit 1; }
+```
+
+### Step 2: Spawn jdi-bootstrap
+Invoke agent. Wait.
+
+### Step 3: Verify result
+- created -> show confirmation, suggest `/jdi-discuss 1`
+- already-exists + keep -> show "already ready", suggest `/jdi-discuss 1`
+- cancelled -> exit clean
+- failed -> show error
+
+### Step 4: MCP audit (token budget)
+
+Applicable to runtimes with MCP (Claude Code, OpenCode). Prints checklist after Step 3 confirmation:
+
+```
+MCP audit (token budget):
+Every enabled MCP injects tool schema in EVERY turn — heavyweight (browser/playwright,
+mac-tools, win-tools) costs 20k+ tokens/turn each. Before starting /jdi-discuss:
+
+  [ ] Browser/playwright enabled? Disable if current phases have no UI work
+  [ ] Platform-specific (mac-tools/win-tools)? Disable if unused
+  [ ] Cross-project MCPs still on from another project?
+  [ ] Duplicate MCPs (2 filesystem helpers, 2 search providers)?
+
+Toggle (Claude Code):  .claude/settings.json -> enabledMcpjsonServers / disabledMcpjsonServers
+Toggle (OpenCode):     .opencode/opencode.jsonc -> mcp.<name>.enabled
+Toggle (Copilot):      n/a (no granular MCP toggle support)
+
+Skip if recently audited.
+```
+
+Does not block. Just reminds. JDI does not manage `.claude/settings.json` or `.opencode/opencode.jsonc` — those belong to runtime, not project state.
+
+</process>
+
+<gates>
+- pre: `.jdi/PROJECT.md` exists + working tree clean (or changes only in `.jdi/`)
+- post: `.jdi/agents/jdi-doer-*.md` and `.jdi/agents/jdi-reviewer-*.md` exist + routing updated + commit + MCP audit checklist shown
+</gates>
+
+<errors>
+- PROJECT.md missing -> suggest `/jdi-new`
+- Architect cancelled -> exit clean
+- Architect failed -> keep state, show error, suggest manual retry
+</errors>

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

@@ -0,0 +1,80 @@
+---
+name: jdi-create
+description: Creates new JDI agent or skill via validated question loop and automatic integration.
+argument_hint: "[optional short description]"
+runtime_intent:
+  invokes_agent: jdi-architect
+runtime_overrides:
+  claude:
+    allowed-tools: [Read, Write, Edit, Bash, Grep, Glob, AskUserQuestion, Agent]
+  copilot:
+    tools: [read, write, edit, terminal]
+  antigravity:
+    triggers:
+      - "/jdi-create"
+      - "create new agent"
+      - "create new skill"
+      - "extend jdi"
+---
+
+<objective>
+Create new agent or skill for JDI through guided flow: question loop -> automatic classification -> validation with user -> generation + integration + smoke test.
+</objective>
+
+<arguments>
+- `description` (optional): free text describing what to create. Speeds up Q1.
+
+Examples:
+- `/jdi-create`
+- `/jdi-create "specialist for Rust with cargo + clippy"`
+- `/jdi-create "reviewer focused on a11y for UI"`
+- `/jdi-create "skill with EF Core 9 conventions"`
+</arguments>
+
+<process>
+
+### Step 1: Validation
+
+```bash
+test -d .jdi/ || { echo "Not a JDI project. Run /jdi-new."; exit 1; }
+test -d core/  || { echo "Source of truth not found. Are you in the JDI repo?"; exit 1; }
+```
+
+### Step 2: Spawn architect
+
+Invoke `jdi-architect`:
+- If free argument provided, pass as context for Q1
+- Otherwise, asker starts from scratch
+
+Wait. Architect runs 12 steps (see `core/agents/jdi-architect.md`).
+
+### Step 3: Verify result
+
+Architect returns 1 of 3 statuses:
+
+- **created** — agent/skill created, integrated, build+install done. Command confirms with user and ends.
+- **cancelled** — user cancelled. Command exits clean, no commit.
+- **failed** — something went wrong (template missing, name conflict, build failed). Show error, suggest retry.
+
+### Step 4: Confirm
+
+If **created**:
+```
+jdi-{name} ({type}) ok. Audit: R-{N}. Commit: {sha}.
+Invoke: {runtime instructions}
+```
+
+</process>
+
+<gates>
+- pre: `.jdi/` exists + `core/` exists + clean working tree (no uncommitted changes in `core/` to avoid conflicts)
+- post: agent/skill created + integration points updated + build+install done + atomic commit
+</gates>
+
+<errors>
+- Not a JDI project -> suggest `/jdi-new`
+- Source `core/` missing -> not the JDI repo, redirect
+- Working tree dirty in `core/` -> ask to commit or stash first
+- User cancelled -> exit with no side effects
+- Build failed -> do not install, show build error, keep core/ updated for manual retry
+</errors>

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

@@ -0,0 +1,80 @@
+---
+name: jdi-discuss
+description: Adaptive question loop to capture locked decisions before planning the phase.
+argument_hint: "<phase_number> [--auto]"
+runtime_intent:
+  invokes_agent: jdi-asker
+runtime_overrides:
+  claude:
+    allowed-tools: [Read, Write, Bash, Grep, Glob, AskUserQuestion, Agent]
+  copilot:
+    tools: [read, write, grep, glob]
+  opencode:
+    agent: jdi-asker
+    subtask: true
+    model: anthropic/claude-sonnet-4-20250514
+  antigravity:
+    triggers:
+      - "/jdi-discuss"
+      - "discuss phase {N}"
+      - "start phase discussion"
+---
+
+<objective>
+Capture locked decisions for the given phase. Output: CONTEXT.md consumed by the planner.
+</objective>
+
+<arguments>
+- `phase_number` (required): phase number, e.g. `1`, `2`, `3.1`
+- `--auto` (optional): asker decides everything, no questions. Use when phase is trivial.
+</arguments>
+
+<process>
+
+### Step 1: Validation
+1. Confirm `.jdi/` exists. If not: "Run /jdi-new first."
+2. Confirm phase exists in ROADMAP.md. If not: "Phase {N} not found."
+3. Confirm CONTEXT.md does not yet exist for phase. If yes: ask "overwrite or skip?"
+
+### Step 2: Spawn asker
+Invoke `jdi-asker` with:
+- `phase_number={N}`
+- `mode=auto` if `--auto`, otherwise `mode=interactive`
+
+Agent runs its own process. Returns when CONTEXT.md is written.
+
+### Step 3: Commit
+After asker finishes:
+```bash
+git add .jdi/phases/{NN-slug}/CONTEXT.md .jdi/DECISIONS.md .jdi/todos.md
+git commit -m "docs({NN-slug}): capture phase context"
+```
+
+### Step 4: Update state
+Edit `.jdi/STATE.md`:
+- `current_phase: {NN-slug}`
+- `next_step: /jdi-plan {N}`
+
+```bash
+git add .jdi/STATE.md
+git commit -m "chore(state): phase {NN} discussed"
+```
+
+### Step 5: Confirm
+```
+CONTEXT.md ok ({lines} lines, {count} decisions, {creep} in todos.md).
+Next: /jdi-plan {N}
+```
+
+</process>
+
+<gates>
+- pre: `.jdi/` exists + phase listed in ROADMAP.md
+- post: CONTEXT.md written + commit made + STATE.md updated
+</gates>
+
+<errors>
+- ROADMAP.md not found -> exit, suggest /jdi-new
+- CONTEXT.md already exists -> ask: overwrite | skip | view
+- jdi-asker fails -> no commit, no state update, show error
+</errors>

package/runtimes/antigravity/skills/jdi-discuss/scripts/run_command.sh

@@ -0,0 +1,62 @@
+#!/usr/bin/env bash
+# Orquestra o comando jdi-discuss.
+# Uso: ./run_command.sh <phase> [--auto]
+# Pre-req: jdi-asker skill executou e produziu CONTEXT.md.
+
+set -euo pipefail
+
+PHASE="${1:?phase number obrigatorio}"
+PADDED=$(printf "%02d" "$PHASE" 2>/dev/null || echo "$PHASE")
+
+PHASE_DIR=$(find .jdi/phases -maxdepth 1 -type d -name "${PADDED}-*" | head -1)
+if [[ -z "$PHASE_DIR" ]]; then
+  echo "Erro: diretorio da phase ${PHASE} nao encontrado."
+  exit 1
+fi
+
+CONTEXT_FILE="${PHASE_DIR}/CONTEXT.md"
+if [[ ! -f "$CONTEXT_FILE" ]]; then
+  echo "Erro: ${CONTEXT_FILE} nao foi escrito pelo asker."
+  exit 1
+fi
+
+# Commit do contexto
+git add "${CONTEXT_FILE}" .jdi/DECISIONS.md .jdi/todos.md 2>/dev/null || true
+git commit -m "docs(${PADDED}): capture phase context" || true
+
+# Atualiza STATE.md
+SLUG=$(basename "$PHASE_DIR")
+NOW=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+
+cat > .jdi/STATE.md <<EOF
+---
+updated: ${NOW}
+last_commit: $(git rev-parse --short HEAD)
+current_phase: ${SLUG}
+next_step: /jdi-plan ${PHASE}
+blockers: []
+---
+
+# State
+
+## Where I am
+Phase ${PHASE} discutida. Decisoes em DECISIONS.md.
+
+## Last activity
+- $(git log -1 --format="%h %s")
+EOF
+
+git add .jdi/STATE.md
+git commit -m "chore(state): phase ${PADDED} discussed"
+
+DECISIONS_COUNT=$(grep -c "^## D-" .jdi/DECISIONS.md 2>/dev/null || echo 0)
+TODOS_COUNT=$(grep -c "^- \[ \]" .jdi/todos.md 2>/dev/null || echo 0)
+
+cat <<EOF
+
+CONTEXT.md: ${CONTEXT_FILE}
+Decisoes totais no projeto: ${DECISIONS_COUNT}
+Todos pendentes: ${TODOS_COUNT}
+
+Proximo: /jdi-plan ${PHASE}
+EOF