kiro

Files (12)

• .specs-watcher-state.json
• NEXT-STEPS.md
• SKILL.md
• com.kiro.webhook-receiver.plist
• config.sh
• kiro_agent.py
• linear-api-kiro.sh
• linear_helper.py
• pipeline-health.sh
• pipeline-status.sh
• specs-watcher.sh
• webhook_receiver.py

SKILL.md (first lines)

# Kiro Agent — Automated Coding via Kiro CLI

You (OpenCode) are the **orchestrator**. Kiro is the **coder**. You spawn Kiro, give it tasks, monitor its work, and handle the git/PR workflow when it's done.

**Everything is remote.** Kiro reads and writes code via the GitHub API — no local file changes. Multiple sessions can run simultaneously on different branches without conflicts.

## When to Use This Skill

- User asks to "build", "implement", "code", "create", or "fix" something or /kiro
- A Linear task is ready for development
- A previous deploy failed and the fix needs to be coded

## Architecture

```
OpenCode (you) ──ACP──> Kiro CLI (codes via GitHub API)
                              │
                              ├── reads files via github-dev scripts
                              ├── writes files via github-dev scripts
                              ├── commits via github-dev scripts
                              │
OpenCode (you) ──gh CLI──> GitHub (branch, PR, labels)
```

## Paths & Constants

```
KIRO_ACP_CLIENT = "/Users/kokayi/Dev/claude-agent-workflow/.opencode/skills/kiro-acp/client.py"
GITHUB_DEV      = "/Users/kokayi/Dev/claude-agent-workflow/.opencode/skills/github-dev/dev"
GITHUB_DEV_DIR  = "/Users/kokayi/Dev/claude-agent-workflow/.opencode/skills/github-dev"
LINEAR_HELPER   = "/Users/kokayi/Dev/claude-agent-workflow/.opencode/skills/kiro/linear_helper.py"
KIRO_AGENT      = "/Users/kokayi/Dev/claude-agent-workflow/.opencode/skills/kiro/kiro_agent.py"

DEFAULT_CWD     = "/Users/kokayi/Dev/consuelo_on_call_coaching"
DEFAULT_REPO    = "kokayicobb/consuelo_on_call_coaching"
```

## Full Workflow

### Step 1: Receive Task

Two entry points:

**Chat entry** — user says "build X" or "implement feature Y":
- Extract the coding task from the conversation
- Construct a detailed prompt for Kiro (more detail = better results)

**Linear spec entry** — task ID provided (e.g., CON-456):
- Fetch the spec: `python3 {GITHUB_DEV_DIR}/fetch_task.py CON-456`
- Read the saved spec file: `{GITHUB_DEV_DIR}/tasks/CON-456.md`
- The spec contains requirements, acceptance criteria, and context

### Step 2: Create Branch

Start a github-dev session to create the working branch:

```bash
# For Linear tasks:
python3 {GITHUB_DEV} task CON-456

# For chat tasks (no Linear):
python3 {GITHUB_DEV} create-branch "add user authentication flow"
```

This creates a remote branch on GitHub and saves session state. Note the branch name from the output.

### Step 3: Spawn Kiro ACP Session

Use the orchestrator to spawn and manage Kiro:

```python
import sys
sys.path.insert(0, "/Users/kokayi/Dev/claude-agent-workflow/.opencode/skills/kiro")
from kiro_agent import KiroSession

# Start a session
session = KiroSession(
    cwd="/Users/kokayi/Dev/consuelo_on_call_coaching",
    repo="kokayicobb/consuelo_on_call_coaching",
)
session.start()

# Send the task
result = session.run_task(
    task_description="Implement user authentication with JWT tokens",
    branch_name="remote/consuelo_on_call_coaching-a3f2--add-user-auth",
    linear_spec=None,  # or the spec text if from Linear
    linear_task_id=None,  # or "CON-456" if from Linear
)

# result contains: what Kiro did, whether it created specs or coded, files changed
```

### Step 4: What Kiro Does (You Don't Control This)

Kiro receives a prompt that instructs it to:

1. **Assess complexity** — is this a straightforward coding task or does it need specs?
2. **If complex** — create Linear issues tagged `kiro` for each piece of work, then STOP
3. **If straightforward** — code the solution using github-dev scripts:
   - Read files: `python3 {GITHUB_DEV} read src/file.tsx`
   - Explore: `python3 {GITHUB_DEV} ls src/` and `python3 {GITHUB_DEV} tree src/`
   - Write files: `echo 'content' | python3 {GITHUB_DEV} write src/new-file.tsx`
   - Or: `python3 {GITHUB_DEV} write src/file.tsx --content-file /tmp/edit.tsx`
   - Commit: `python3 {GITHUB_DEV} commit "feat: add user auth"`
   - Can do multiple write+commit cycles

### Step 5: Monitor Progress

While Kiro works, you monitor via streaming. The orchestrator (`kiro_agent.py`) handles this, but key things to watch for:

- **ToolCall events with "linear" mentions** — Kiro is creating specs → session will end without coding
- **ToolCall events with file operations** — Kiro is coding, relay significant updates to chat
- **Kiro saying "created specs" or "created issues"** — end session, report specs
- **TurnEnd** — Kiro's turn is complete, evaluate

Relay significant progress to Ko's chat:
- "Kiro is reading the codebase structure..."
- "Kiro is writing src/components/Auth.tsx..."

From consuelohq/openengineer, MIT.

More from consuelohq/openengineer