@kraftapps-ai/kai 1.0.0

package/README.md

@@ -0,0 +1,161 @@
+# Kai
+
+Autonomous AI developer loop for [Claude Code](https://claude.ai/claude-code). Kai takes a list of user stories and implements them one by one — with a built-in reviewer that catches when the AI cuts corners.
+
+## How it works
+
+```
+┌─────────────┐     ┌──────────────┐     ┌──────────────┐
+│  kai.json │────▶│ Implementer  │────▶│   Reviewer   │
+│  (stories)  │     │ (claude -p)  │     │ (claude -p)  │
+└─────────────┘     └──────┬───────┘     └──────┬───────┘
+                           │                     │
+                    commits code          verifies against
+                    marks passes:true     acceptance criteria
+                           │                     │
+                           │    ┌────────┐       │
+                           └───▶│  Loop  │◀──────┘
+                                │ repeat │  (fail = retry)
+                                └────────┘
+```
+
+1. **Picks** the next incomplete story from `kai.json`
+2. **Implements** it using Claude Code (one `claude -p` call)
+3. **Reviews** the implementation with a separate Claude call that verifies each acceptance criterion against the actual git diff
+4. **Retries** if the review fails (up to 3 attempts, then skips)
+5. **Loops** to the next story
+
+Each iteration starts fresh — no context pollution between stories.
+
+## Install
+
+```bash
+npm i -g @kraftapps-ai/kai
+```
+
+Or without installing:
+
+```bash
+npx @kraftapps-ai/kai init
+npx @kraftapps-ai/kai plan "add auth"
+npx @kraftapps-ai/kai go
+```
+
+**Requirements:** `claude` CLI ([Claude Code](https://claude.ai/claude-code)), `jq`, `git`
+
+## Quick start
+
+```bash
+cd your-project
+
+# Initialize
+kai init
+
+# Add your project context (tech stack, build commands, conventions)
+vim .kai/PROMPT.md
+
+# Plan with AI PM — brainstorm, refine, generate stories
+kai plan "add user authentication with OAuth"
+# → AI generates stories → confirms → adds to kai.json
+
+# Check what's queued
+kai status
+
+# Let Kai implement everything
+kai go
+```
+
+## Commands
+
+| Command | Description |
+|---|---|
+| `kai init` | Initialize kai in the current project |
+| `kai plan "topic"` | AI PM generates stories and adds them to kai.json |
+| `kai go` | Run the implement + review loop |
+| `kai status` | Show progress and remaining stories |
+| `kai reset <id>` | Reset a story to incomplete |
+| `kai help` | Show help |
+
+## Files
+
+After `kai init`, your project gets:
+
+```
+your-project/
+├── kai.json            # Stories (version control this)
+├── kai-progress.txt    # Implementation log (version control this)
+└── .kai/
+    ├── PROMPT.md         # Instructions for Claude (customize this!)
+    └── context.txt       # Optional: extra files to include (one per line)
+```
+
+### Adding project context
+
+Edit `.kai/PROMPT.md` to include your project's specifics — tech stack, file structure, build commands, coding conventions. The more context you give, the better Kai performs.
+
+### Extra context files
+
+Create `.kai/context.txt` with paths to files that should be included in every iteration:
+
+```
+AGENTS.md
+docs/ARCHITECTURE.md
+```
+
+## Story format
+
+```json
+{
+  "id": 1,
+  "title": "Add user login page",
+  "description": "Create a login page with email/password",
+  "acceptanceCriteria": [
+    "Login page renders at /login",
+    "Email and password fields present",
+    "App builds successfully"
+  ],
+  "priority": 1,
+  "passes": false
+}
+```
+
+Stories are processed in `priority` order (lowest first). The `passes` flag is set to `true` by the implementer and verified by the reviewer.
+
+## The review step
+
+After the implementer commits, Kai dispatches a **separate Claude instance** as a reviewer. The reviewer:
+
+1. Reads the actual git diff (not the implementer's self-report)
+2. Verifies each acceptance criterion against the code
+3. Is explicitly told: *"Do NOT trust the implementer. Verify independently."*
+
+If the review fails, the story is reset to `passes: false` and the feedback is appended to `kai-progress.txt` so the next iteration sees what went wrong.
+
+After 3 consecutive failures on the same story, Kai skips it with a `concerns` flag and moves on.
+
+## Rationalization blockers
+
+The prompt includes a table of common ways AI agents cheat, with counters:
+
+- "This is already implemented" → Verify. Read the code.
+- "I'll just mark it complete" → Every story needs real code changes.
+- "The build passes so it works" → Build ≠ correct behavior.
+- "This is close enough" → Partial = broken.
+
+Inspired by [Superpowers](https://github.com/obra/superpowers).
+
+## Tips
+
+- **Write good acceptance criteria.** "App builds successfully" should always be the last criterion.
+- **Keep stories small.** 5-15 minutes of work each. Kai does better with many small stories than few large ones.
+- **Add build/test commands** to `.kai/PROMPT.md` so Kai knows how to verify.
+- **Use `kai status`** to monitor progress, or `git log --oneline` to see commits.
+- **Run overnight.** `nohup kai go > kai.log 2>&1 &` and check in the morning.
+
+## Cost
+
+Each story costs roughly 2 Claude API calls (1 implement + 1 review). A 20-story project runs ~40 calls. At current Claude pricing, that's a few dollars total.
+
+## License
+
+MIT

package/kai

@@ -0,0 +1,495 @@
+#!/bin/bash
+# Kai — Autonomous AI developer loop for Claude Code
+# https://github.com/kraftapps-ai/kai
+#
+# Usage:
+#   kai              — Show help
+#   kai init         — Initialize kai in current project
+#   kai plan [topic] — Interactive brainstorm with AI PM, generates stories
+#   kai import       — Import stories from JSON
+#   kai go           — Run the implement + review loop
+#   kai status       — Show remaining stories
+#   kai reset <id>   — Reset a story to incomplete
+
+set -e
+
+KAI_DIR="$(cd "$(dirname "$0")" && pwd)"
+PROJECT_DIR="$(pwd)"
+PRD_FILE="kai.json"
+PROGRESS_FILE="kai-progress.txt"
+PROMPT_FILE=".kai/PROMPT.md"
+
+# ── Help ───────────────────────────────────────────────
+
+cmd_help() {
+    cat << 'EOF'
+Kai — Autonomous AI developer loop for Claude Code
+
+Commands:
+  kai init             Initialize kai in the current project
+  kai plan "topic"     AI generates stories from your description
+  kai go               Run the implement + review loop
+  kai status           Show progress and remaining stories
+  kai reset <id>       Reset a story to incomplete
+  kai help             Show this help
+
+Workflow:
+  1. kai init                       # setup
+  2. vim .kai/PROMPT.md             # add project context
+  3. kai plan "add user auth"       # AI generates stories
+  4. kai go                         # AI implements everything
+
+Requirements: claude (Claude Code CLI), jq, git
+
+https://github.com/kraftapps-ai/kai
+EOF
+}
+
+# ── Commands ───────────────────────────────────────────
+
+cmd_init() {
+    if [ -f "$PRD_FILE" ]; then
+        echo "kai.json already exists. Aborting."
+        exit 1
+    fi
+
+    mkdir -p .kai
+
+    cat > "$PRD_FILE" << 'JSONEOF'
+{
+  "branchName": "main",
+  "userStories": []
+}
+JSONEOF
+
+    echo "# Kai Progress Log" > "$PROGRESS_FILE"
+    echo "" >> "$PROGRESS_FILE"
+
+    cat > "$PROMPT_FILE" << 'PROMPTEOF'
+You are an autonomous AI developer.
+
+## Your inputs
+- `@kai.json` — user stories with `passes: true/false`.
+- `@kai-progress.txt` — append-only log of what's been done.
+
+## Your task (ONE story per loop)
+
+1. Read kai.json and find the highest-priority story where `passes: false`.
+2. Read kai-progress.txt to understand what's already been done.
+3. **PLAN before coding.** List the files you'll change and what you'll do in each.
+4. Implement ONLY that one story.
+5. Run verification (build, tests, lint — whatever applies).
+6. **SELF-REVIEW.** For each acceptance criterion, state what you did and cite evidence (file, line, command output). Do NOT use "should work", "probably", or "seems to".
+7. If all criteria pass, commit with a descriptive message.
+8. Update kai.json: set `passes` to `true`.
+9. Append to kai-progress.txt: what you did, what you learned.
+
+## Verification Protocol
+
+- Run the project's build/test command and read the output.
+- You cannot claim a criterion is met without evidence.
+- "I added the component" is NOT evidence. "I added FooComponent at src/Foo.tsx:45 and the build passes" IS evidence.
+
+## Rules
+
+- ONE STORY PER LOOP. Do not work on multiple stories.
+- Search the codebase before assuming anything.
+- No placeholder implementations. Fully implement or report BLOCKED.
+- Do not break existing functionality.
+- Keep commits atomic — one commit per story.
+- If ALL stories have `passes: true`, output: <promise>COMPLETE</promise>
+
+## Rationalization Blockers
+
+| Your thought | Why it's wrong | Do this instead |
+|---|---|---|
+| "This story is already implemented" | You haven't verified. | Read every criterion, find the code, run the build. |
+| "I'll just mark it complete" | A commit with only kai.json changes is wrong. | Every story needs real code changes. |
+| "The build passes so it works" | Build ≠ correct behavior. | Verify each criterion independently. |
+| "I'll fix other issues I noticed" | Scope creep introduces bugs. | Only implement the current story. |
+| "This is close enough" | Partial = broken for the user. | Implement ALL criteria or report BLOCKED. |
+| "I'll skip the review, it's simple" | Simple code has bugs too. | Always self-review against criteria. |
+| "I need to refactor first" | Refactoring without a story = scope creep. | Only refactor if the story requires it. |
+
+## Status Reporting
+
+- **DONE** — All criteria met, build passes, committed.
+- **DONE_WITH_CONCERNS** — Completed but something feels off. Document in `concerns` field.
+- **BLOCKED** — Cannot complete. Document why in kai-progress.txt.
+- **NEEDS_CONTEXT** — Missing information. Document in kai-progress.txt.
+PROMPTEOF
+
+    echo "Kai initialized."
+    echo ""
+    echo "  Created: kai.json, kai-progress.txt, .kai/PROMPT.md"
+    echo ""
+    echo "Next:"
+    echo "  1. Edit .kai/PROMPT.md with your project context"
+    echo "  2. kai plan \"what you want to build\""
+    echo "  3. kai go"
+}
+
+cmd_plan() {
+    topic="${1:-}"
+
+    if [ ! -f "$PRD_FILE" ]; then
+        echo "kai.json not found. Run 'kai init' first."
+        exit 1
+    fi
+
+    # Build context about existing stories
+    existing=""
+    story_count=$(jq '.userStories | length' "$PRD_FILE")
+    if [ "$story_count" -gt 0 ]; then
+        existing="
+
+Existing stories in kai.json (don't duplicate these):
+$(jq -r '.userStories[] | "- [\(if .passes then "done" else "todo" end)] \(.title)"' "$PRD_FILE")"
+    fi
+
+    # Build context about the project
+    project_context=""
+    if [ -f "$PROMPT_FILE" ]; then
+        project_context="
+
+Project context from .kai/PROMPT.md:
+$(cat "$PROMPT_FILE")"
+    fi
+
+    # PM system prompt
+    pm_prompt="You are a senior product manager and technical architect. You're planning work with a developer.
+
+Your job:
+1. Understand what they want to build or improve
+2. Ask clarifying questions (target user, constraints, scope)
+3. Break the work into small, implementable stories (5-15 min each)
+4. Each story needs: title, description, and specific acceptance criteria
+5. Stories should be ordered by dependency (build foundations first)
+
+Rules for good stories:
+- Each story should be independently committable
+- Last acceptance criterion should always be \"App builds successfully\" or equivalent
+- Acceptance criteria must be verifiable (not vague like \"looks good\")
+- Keep stories small — if it takes more than 15 min, split it
+- Include edge cases and error handling as separate stories
+- Don't forget: tests, error states, loading states, empty states
+
+When the user is happy with the plan, output the stories in this EXACT format — one JSON block with all stories:
+
+\`\`\`kai-stories
+[
+  {
+    \"title\": \"Story title here\",
+    \"description\": \"What to implement and why\",
+    \"acceptanceCriteria\": [\"Criterion 1\", \"Criterion 2\", \"App builds successfully\"]
+  }
+]
+\`\`\`
+
+The user will say \"looks good\" or \"ship it\" when they want you to output the final stories.
+${existing}${project_context}"
+
+    # Generate a session ID so we can find the transcript after
+    SESSION_ID=$(python3 -c "import uuid; print(uuid.uuid4())" 2>/dev/null || uuidgen 2>/dev/null || cat /proc/sys/kernel/random/uuid 2>/dev/null)
+
+    if [ -n "$topic" ]; then
+        echo "Planning: $topic"
+        echo "Say 'ship it' when you're happy with the stories."
+        echo ""
+        claude --session-id "$SESSION_ID" --system-prompt "$pm_prompt" "Let's plan: $topic"
+    else
+        echo "Describe what you want to build. Say 'ship it' when ready."
+        echo ""
+        claude --session-id "$SESSION_ID" --system-prompt "$pm_prompt"
+    fi
+
+    # After session ends, find the transcript and extract stories
+    echo ""
+    echo "Scanning session for stories..."
+
+    # Find the project transcript directory
+    project_dir=$(echo "$PROJECT_DIR" | sed 's|/|-|g; s|^-||')
+    transcript=""
+    for dir in ~/.claude/projects/*/; do
+        if [ -f "${dir}${SESSION_ID}.jsonl" ]; then
+            transcript="${dir}${SESSION_ID}.jsonl"
+            break
+        fi
+    done
+
+    if [ -z "$transcript" ] || [ ! -f "$transcript" ]; then
+        echo "Could not find session transcript."
+        echo "If stories were generated, you can manually add them to kai.json."
+        return
+    fi
+
+    # Extract kai-stories JSON from the transcript
+    stories_json=$(python3 -c "
+import json, re, sys
+
+stories = None
+with open('$transcript') as f:
+    for line in f:
+        try:
+            d = json.loads(line)
+            if d.get('type') == 'assistant':
+                content = d.get('message', {}).get('content', [])
+                if isinstance(content, list):
+                    for c in content:
+                        if c.get('type') == 'text':
+                            text = c['text']
+                            # Find kai-stories block
+                            match = re.search(r'\`\`\`kai-stories\s*\n(.*?)\n\`\`\`', text, re.DOTALL)
+                            if match:
+                                stories = match.group(1)
+        except: pass
+
+if stories:
+    # Validate it's valid JSON
+    parsed = json.loads(stories)
+    print(json.dumps(parsed))
+" 2>/dev/null)
+
+    if [ -n "$stories_json" ] && echo "$stories_json" | jq empty 2>/dev/null; then
+        count=$(echo "$stories_json" | jq 'length')
+        echo ""
+        echo "Found ${count} stories:"
+        echo "$stories_json" | jq -r '.[] | "  - \(.title)"'
+        echo ""
+        echo "Add to kai.json? (y/n)"
+        read -r confirm
+        if [ "$confirm" = "y" ] || [ "$confirm" = "Y" ] || [ "$confirm" = "" ]; then
+            _import_stories "$stories_json"
+        else
+            echo "Skipped."
+        fi
+    else
+        echo "No stories found in session."
+        echo "If the PM generated stories, you can copy the JSON and add manually to kai.json."
+    fi
+}
+
+_import_stories() {
+    local stories_json="$1"
+
+    if ! echo "$stories_json" | jq empty 2>/dev/null; then
+        echo "Invalid JSON."
+        return 1
+    fi
+
+    max_id=$(jq '[.userStories[].id] | max // 0' "$PRD_FILE")
+    count=$(echo "$stories_json" | jq 'length')
+
+    echo "$stories_json" | jq -c '.[]' | while IFS= read -r story; do
+        max_id=$((max_id + 1))
+        title=$(echo "$story" | jq -r '.title')
+        desc=$(echo "$story" | jq -r '.description')
+        criteria=$(echo "$story" | jq '.acceptanceCriteria')
+
+        jq --arg title "$title" \
+           --arg desc "$desc" \
+           --argjson id "$max_id" \
+           --argjson criteria "$criteria" \
+           '.userStories += [{
+             id: $id,
+             title: $title,
+             description: $desc,
+             acceptanceCriteria: $criteria,
+             priority: $id,
+             passes: false
+           }]' "$PRD_FILE" > "${PRD_FILE}.tmp" && mv "${PRD_FILE}.tmp" "$PRD_FILE"
+
+        echo "  #${max_id}: ${title}"
+    done
+
+    echo ""
+    echo "Added ${count} stories."
+}
+
+cmd_status() {
+    if [ ! -f "$PRD_FILE" ]; then
+        echo "kai.json not found. Run 'kai init' first."
+        exit 1
+    fi
+
+    total=$(jq '.userStories | length' "$PRD_FILE")
+    done_count=$(jq '[.userStories[] | select(.passes == true)] | length' "$PRD_FILE")
+    remaining=$((total - done_count))
+
+    echo "Kai: ${done_count}/${total} complete (${remaining} remaining)"
+    echo ""
+
+    if [ "$remaining" -gt 0 ]; then
+        echo "Remaining:"
+        jq -r '.userStories[] | select(.passes == false) | "  \(.id): \(.title)"' "$PRD_FILE"
+    fi
+}
+
+cmd_reset() {
+    id="$1"
+    if [ -z "$id" ]; then
+        echo "Usage: kai reset <story-id>"
+        exit 1
+    fi
+
+    jq --argjson id "$id" '(.userStories[] | select(.id == $id)).passes = false' "$PRD_FILE" > "${PRD_FILE}.tmp" && mv "${PRD_FILE}.tmp" "$PRD_FILE"
+    echo "Reset story #${id}."
+}
+
+cmd_go() {
+    if [ ! -f "$PRD_FILE" ]; then
+        echo "kai.json not found. Run 'kai init' first."
+        exit 1
+    fi
+
+    if [ ! -f "$PROMPT_FILE" ]; then
+        echo ".kai/PROMPT.md not found. Run 'kai init' first."
+        exit 1
+    fi
+
+    # Collect context files
+    context_files="@${PROMPT_FILE} @${PRD_FILE} @${PROGRESS_FILE}"
+    if [ -f ".kai/context.txt" ]; then
+        while IFS= read -r file; do
+            [ -n "$file" ] && [ -f "$file" ] && context_files="$context_files @${file}"
+        done < .kai/context.txt
+    fi
+
+    echo "Starting Kai..."
+    echo "  Stories remaining: $(jq '[.userStories[] | select(.passes == false)] | length' "$PRD_FILE")"
+    echo "  Ctrl+C to stop"
+    echo ""
+
+    iteration=0
+    review_failures=0
+
+    while :; do
+        iteration=$((iteration + 1))
+        REMAINING=$(jq '[.userStories[] | select(.passes == false)] | length' "$PRD_FILE")
+
+        if [ "$REMAINING" -eq 0 ]; then
+            echo "All stories complete!"
+            break
+        fi
+
+        NEXT_ID=$(jq -r '[.userStories[] | select(.passes == false)] | sort_by(.priority) | .[0].id' "$PRD_FILE")
+        NEXT=$(jq -r '[.userStories[] | select(.passes == false)] | sort_by(.priority) | .[0].title' "$PRD_FILE")
+
+        echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+        echo "#${iteration} — $(date)"
+        echo "  Remaining: $REMAINING | Next: $NEXT"
+        echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+
+        start_time=$(date +%s)
+
+        # ── Implement ──────────────────────────────────
+        set +e
+        result=$(claude -p \
+          --dangerously-skip-permissions \
+          $context_files)
+        exit_code=$?
+        set -e
+
+        end_time=$(date +%s)
+        elapsed=$(( end_time - start_time ))
+        minutes=$(( elapsed / 60 ))
+        seconds=$(( elapsed % 60 ))
+
+        echo "$result" | tail -20
+        echo ""
+
+        if [ $exit_code -ne 0 ]; then
+            echo "Iteration #${iteration} failed (code ${exit_code}). Restarting..."
+            continue
+        fi
+
+        if [[ "$result" == *"<promise>COMPLETE</promise>"* ]]; then
+            echo "All stories complete after $iteration iterations!"
+            exit 0
+        fi
+
+        # ── Review ─────────────────────────────────────
+        STORY_PASSES=$(jq -r ".userStories[] | select(.id == $NEXT_ID) | .passes" "$PRD_FILE")
+
+        if [ "$STORY_PASSES" = "true" ]; then
+            last_commit=$(git log --oneline -1 2>/dev/null || echo "no git")
+            last_diff_stat=$(git diff --stat HEAD~1 HEAD 2>/dev/null | tail -1)
+
+            # Sanity: real code changes?
+            if [ -z "$last_diff_stat" ] || [[ "$last_diff_stat" == *"0 insertions"*"0 deletions"* ]]; then
+                echo "REVIEW FAIL: No code changes in commit!"
+                jq --argjson id "$NEXT_ID" '(.userStories[] | select(.id == $id)).passes = false' "$PRD_FILE" > "${PRD_FILE}.tmp" && mv "${PRD_FILE}.tmp" "$PRD_FILE"
+                review_failures=$((review_failures + 1))
+                if [ $review_failures -ge 3 ]; then
+                    echo "3 failures on story #${NEXT_ID}. Skipping."
+                    jq --argjson id "$NEXT_ID" '(.userStories[] | select(.id == $id)).passes = true | (.userStories[] | select(.id == $id)).concerns = "Skipped after 3 failures"' "$PRD_FILE" > "${PRD_FILE}.tmp" && mv "${PRD_FILE}.tmp" "$PRD_FILE"
+                    review_failures=0
+                fi
+                continue
+            fi
+
+            # Dispatch reviewer
+            echo "Reviewing story #${NEXT_ID}..."
+            ACCEPTANCE=$(jq -r ".userStories[] | select(.id == $NEXT_ID) | .acceptanceCriteria | join(\"\n- \")" "$PRD_FILE")
+
+            set +e
+            review_result=$(claude -p \
+              --dangerously-skip-permissions \
+              "You are a code reviewer. The implementer claims story #${NEXT_ID} ('${NEXT}') is complete.
+
+Last commit: ${last_commit}
+Changes: ${last_diff_stat}
+
+Acceptance criteria:
+- ${ACCEPTANCE}
+
+Instructions:
+1. Read the changed files (git diff HEAD~1 HEAD).
+2. For EACH criterion, verify it is met by the actual code. Be skeptical.
+3. Run the build/test command if applicable.
+4. If ANY criterion is not met: REVIEW_FAIL: [which criterion and why]
+5. If all criteria met: REVIEW_PASS
+
+Do NOT trust the implementer's self-report. Verify independently.")
+            review_exit=$?
+            set -e
+
+            echo "$review_result" | tail -10
+
+            if [[ "$review_result" == *"REVIEW_FAIL"* ]]; then
+                echo "Review failed!"
+                jq --argjson id "$NEXT_ID" '(.userStories[] | select(.id == $id)).passes = false' "$PRD_FILE" > "${PRD_FILE}.tmp" && mv "${PRD_FILE}.tmp" "$PRD_FILE"
+                echo "" >> "$PROGRESS_FILE"
+                echo "## REVIEW FEEDBACK for Story $NEXT_ID" >> "$PROGRESS_FILE"
+                echo "$review_result" | grep -i "REVIEW_FAIL" >> "$PROGRESS_FILE" 2>/dev/null
+                review_failures=$((review_failures + 1))
+                if [ $review_failures -ge 3 ]; then
+                    echo "3 review failures on story #${NEXT_ID}. Skipping."
+                    jq --argjson id "$NEXT_ID" '(.userStories[] | select(.id == $id)).passes = true | (.userStories[] | select(.id == $id)).concerns = "Passed after 3 review attempts"' "$PRD_FILE" > "${PRD_FILE}.tmp" && mv "${PRD_FILE}.tmp" "$PRD_FILE"
+                    review_failures=0
+                fi
+            else
+                echo "Review passed."
+                review_failures=0
+            fi
+        fi
+
+        echo "Iteration #${iteration} done in ${minutes}m ${seconds}s"
+        last_commit=$(git log --oneline -1 2>/dev/null || echo "")
+        [ -n "$last_commit" ] && echo "  Last commit: ${last_commit}"
+        echo ""
+    done
+
+    echo "Kai finished after ${iteration} iterations."
+}
+
+# ── Main ───────────────────────────────────────────────
+
+case "${1:-help}" in
+    init)    cmd_init ;;
+    plan)    shift; cmd_plan "$@" ;;
+    go)      cmd_go ;;
+    status)  cmd_status ;;
+    reset)   shift; cmd_reset "$@" ;;
+    help|*)  cmd_help ;;
+esac

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@kraftapps-ai/kai",
+  "version": "1.0.0",
+  "description": "Autonomous AI developer loop for Claude Code",
+  "bin": {
+    "kai": "kai"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "ai",
+    "developer",
+    "autonomous",
+    "coding-agent",
+    "cli"
+  ],
+  "author": "kraftapps-ai",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kraftapps-ai/kai.git"
+  },
+  "homepage": "https://github.com/kraftapps-ai/kai",
+  "publishConfig": {
+    "access": "public"
+  }
+}