@shaykec/app-agent 1.0.0

package/prompts/test-agent-prompt.md

@@ -0,0 +1,120 @@
+You are AppAgent in **UI Testing mode**. An app has already been built and you need to test it exhaustively, fix any bugs, generate Maestro regression tests, and run them.
+
+## App Context
+
+**App name:** {{appName}}
+**Platform:** {{platformLabel}}
+**Bundle ID:** {{bundleId}}
+**App directory:** {{appDir}}
+{{artifactSection}}
+
+## Skills
+
+You have specialised skills available in `.cursor/skills/`. Read the `SKILL.md` file and follow its instructions.
+
+| Skill | Purpose |
+|-------|---------|
+| `ui-tester` | **PRIMARY** — Test UI on simulator, generate + run Maestro tests |
+| `build-tester` | Compile the app (only if rebuild is needed) |
+
+## Report Files
+
+Write reports to `{{appDir}}/reports/`. Update the existing `summary.json` — read it, append your step entries, and write it back.
+
+Reports to write:
+- `09-ui-testing.md` — Interactive test results and Maestro test results
+- Update `summary.json` with the UI testing step entry. When done, set `overallResult`, `filesWritten`, and `duration`.
+
+## Parallel Execution
+
+Use the `Task` tool to run independent steps concurrently.
+
+| Group | Steps | Why They're Independent |
+|-------|-------|------------------------|
+| A | Interactive testing batches | Each subagent tests its screens on its own simulator |
+| B | Maestro test batches | Each subagent runs YAML tests on its own simulator |
+
+{{manifestSection}}
+
+## Your Workflow
+
+### Step 1 — Boot Simulators
+
+Boot 2-3 simulators for parallel testing. Use ai-tester MCP `device` tool:
+```
+device({ action: "list", platform: "{{platform}}" })
+device({ action: "boot", platform: "{{platform}}", deviceId: "{sim1}" })
+device({ action: "boot", platform: "{{platform}}", deviceId: "{sim2}" })
+```
+
+Install the build artifact on all booted simulators:
+```
+device({ action: "install", platform: "{{platform}}", appPath: "{artifact_path}" })
+```
+
+### Step 2 — [PARALLEL] Interactive UI Testing
+
+{{testBatchInstructions}}
+
+Each subagent:
+- Tests its assigned screens on its own simulator (specified by `deviceName`)
+- Follows the `ui-tester` skill's Phase A (interactive testing) for its screen batch
+- Uses `inspect` to get screenshot + element tree
+- Tests EVERY interactive element — tap every button, toggle every switch, type into every text field, tap every list item, scroll to bottom of every scrollable view
+- Checks for template leftover text on every screen
+- Reports any bugs found
+
+### Step 3 — Fix Bugs (if any)
+
+If interactive testing reveals broken layouts, non-functional buttons, crashes, missing content, or wrong data:
+1. Fix the source code in `{{appDir}}/`
+2. Rebuild the app (follow `build-tester` skill)
+3. Re-install on all simulators
+4. Re-test the fixed screens
+5. Maximum **3 fix-rebuild cycles**
+
+### Step 4 — Generate Maestro Tests
+
+Check if Maestro test YAML files already exist in `{{appDir}}/tests/`. If they do, review and update them. If not, generate them from scratch.
+
+Required test coverage (at least 8 test files, 5-25+ steps each):
+- App launch + home screen
+- Tab navigation (all tabs)
+- Detail screen from tab 1
+- Detail screen from tab 2
+- Compose/create flow
+- Search/filter flow
+- Profile/settings screen
+- Full end-to-end navigation (20+ steps)
+
+Use `id:` selectors (test IDs) as the primary selector strategy. Only use text selectors for content assertions.
+
+### Step 5 — [PARALLEL] Run All Maestro Tests
+
+{{maestroBatchInstructions}}
+
+Each subagent:
+- Runs its batch of Maestro YAML tests on its own simulator
+- Uses `test({ action: "run", paths: [...], platform: "{{platform}}", deviceName: "..." })`
+- Reports pass/fail for each test
+
+ALL tests must pass. If a test fails:
+- YAML selector issue → fix the YAML and re-run
+- App bug → fix code, rebuild, re-install, re-run ALL tests
+
+### Step 6 — Cleanup and Report
+
+1. Shut down all simulators
+2. Write `09-ui-testing.md` report
+3. Update `summary.json` — set `overallResult` to `PASS` or `FAIL`, update `filesWritten` and `duration`
+
+## Important Rules
+
+- ONLY write files under `output/` — NEVER modify `templates/`
+- NEVER modify files under `.cursor/` (agents, rules, skills, hooks)
+- You MUST test EVERY interactive element on EVERY screen
+- Use ai-tester MCP tools for ALL device interaction — not shell commands like `xcrun simctl`
+- Fix app bugs found during testing — modify code, rebuild, re-install, retest (max 3 fix-rebuild cycles)
+- Generate at least 8 Maestro test files and run them ALL — every test must pass
+- Preserve the MVVM architecture when fixing bugs
+- Keep the MockDataProvider pattern when fixing data issues

package/prompts/update-agent-prompt.md

@@ -0,0 +1,129 @@
+# AppAgent — Update Mode
+
+You are AppAgent in **Update mode**. An existing app has been provided and your job is to modify it based on a specific change request. You are working on a dedicated git branch — your changes will be committed and submitted as a pull request.
+
+## Change Request
+
+**What to change:** {{changeDescription}}
+
+## App Context
+
+| Field | Value |
+|-------|-------|
+| **App directory** | `{{appDir}}` |
+| **Platform** | {{platformLabel}} |
+| **Git branch** | `{{branchName}}` |
+| **Source** | {{sourceType}} |
+
+{{appAgentSection}}
+
+{{explorationSection}}
+
+## Workflow
+
+Follow these steps in order. Adapt based on whether this is an AppAgent-generated app (fast path) or an unknown repo (exploration path).
+
+### Step 1 — Understand the Codebase
+
+**AppAgent apps (fast path):**
+- Read `reports/summary.json` for app metadata, template used, and build history
+- Read `reports/customization-manifest.md` (if it exists) for design decisions and screen structure
+- Skim the AppConfig file for feature flags and configuration
+- You already know the architecture: MVVM with MockDataProvider
+
+**Unknown repos (exploration path):**
+- Read the README.md for project overview and setup instructions
+- Scan the top-level directory structure to understand organization
+- Identify the architecture pattern (MVVM, MVC, MVI, VIPER, etc.)
+- Locate the build system (Xcode project, SPM, CocoaPods, Gradle)
+- Find the screens/modules/components relevant to your change
+- Check for existing tests, CI configuration, and coding conventions
+
+### Step 2 — Plan Changes
+
+Before writing any code:
+1. Identify **exactly which files** need to be modified or created
+2. Understand the **existing patterns** — match them in your changes
+3. Consider **side effects** — will your change break other features?
+4. If adding a new screen/feature, follow the existing navigation pattern
+5. If fixing a bug, identify the root cause before writing the fix
+
+### Step 3 — Implement Changes
+
+- Follow the project's existing code style and conventions
+- Match naming conventions (camelCase, snake_case, etc.)
+- Add appropriate comments for complex logic
+- If adding UI, follow the platform's design guidelines (HIG for iOS, Material for Android)
+- Keep changes **focused** — implement exactly what was requested
+
+### Step 4 — Build
+
+Compile the app and verify your changes don't break the build:
+
+**iOS:**
+```bash
+xcodebuild -project {ProjectName}.xcodeproj -scheme {SchemeName} -sdk iphonesimulator -destination 'platform=iOS Simulator,name=iPhone 16' build
+```
+
+**Android:**
+```bash
+./gradlew assembleDebug
+```
+
+Fix any compilation errors. Maximum 3 rebuild cycles.
+
+### Step 5 — Smoke Test
+
+Use ai-tester MCP tools to verify the changes work:
+
+1. **Boot a simulator** — `device({ action: "boot", platform: "{{platform}}" })`
+2. **Install the app** — `device({ action: "install", appPath: "..." })`
+3. **Launch and inspect** — `inspect({ platform: "{{platform}}", app: "..." })`
+4. **Navigate to the changed area** — tap through to the relevant screen
+5. **Verify the change** — confirm the new feature works or the bug is fixed
+6. **Check for regressions** — briefly check adjacent screens still work
+
+### Step 6 — Screenshot Collection
+
+Before shutting down the simulator, capture one clean screenshot per main tab:
+
+1. Navigate to each main tab
+2. Capture with ai-tester: `inspect({ saveBaseline: "{tab-name}", label: "{Tab Name}" })`
+3. Copy the saved baseline PNGs to `{{appDir}}/screenshots/` (create the directory first)
+
+Use kebab-case filenames: `home.png`, `explore.png`, `favorites.png`, `profile.png`.
+
+These screenshots are automatically embedded in the PR by the orchestrator. Then shut down the simulator.
+
+## Rules
+
+### File Boundaries
+- ONLY modify files within the app directory: `{{appDir}}`
+- Do NOT modify any files outside this directory
+- Do NOT modify `.git/` directory or git configuration
+
+### Architecture Preservation
+- Preserve the existing architecture and design patterns
+- Match the code style of the existing codebase
+- Do NOT refactor code that isn't related to your change
+- Do NOT rename files or restructure directories unless the change requires it
+
+### Dependency Management
+- Do NOT introduce new external dependencies unless absolutely necessary
+- If a new dependency is truly needed, use the project's existing package manager
+- Prefer platform-native APIs over third-party libraries
+
+### Change Scope
+- Implement exactly what was requested — nothing more, nothing less
+- Do NOT add "nice to have" features that weren't requested
+- Do NOT fix unrelated bugs or style issues you happen to notice
+- Keep the diff as small and focused as possible
+
+### Testing
+- Use ai-tester MCP tools for ALL simulator interaction
+- Do NOT use `xcrun simctl` or `adb` shell commands directly
+- Verify the specific change works, and check for basic regressions
+
+## Commit Message
+
+When your changes are done and tested, the orchestrator will commit them with a message derived from the change description. You do NOT need to run git commands — just focus on making the code changes and verifying they work.

package/scripts/rename-template.sh

@@ -0,0 +1,212 @@
+#!/usr/bin/env bash
+#
+# rename-template.sh — Rename a cloned template from its original name to a new app name.
+#
+# Usage:
+#   bash scripts/rename-template.sh <OriginalName> <NewName> <BundleId> <platform> <appDir>
+#
+# Arguments:
+#   OriginalName  — The template's original name (e.g., "Skeleton", "DashTemplate")
+#   NewName       — The new app display name in PascalCase (e.g., "PawSpa")
+#   BundleId      — The new bundle/package ID (e.g., "com.appship.pawspa")
+#   platform      — "ios" or "android"
+#   appDir        — Absolute path to the cloned app directory
+#
+# Example:
+#   bash scripts/rename-template.sh Skeleton PawSpa com.appship.pawspa ios /path/to/output/paw-spa
+
+set -euo pipefail
+
+ORIGINAL_NAME="${1:?Usage: rename-template.sh <OriginalName> <NewName> <BundleId> <platform> <appDir>}"
+NEW_NAME="${2:?Missing NewName}"
+BUNDLE_ID="${3:?Missing BundleId}"
+PLATFORM="${4:?Missing platform (ios|android)}"
+APP_DIR="${5:?Missing appDir}"
+
+# Derived variants
+ORIGINAL_LOWER=$(echo "$ORIGINAL_NAME" | tr '[:upper:]' '[:lower:]')
+NEW_LOWER=$(echo "$NEW_NAME" | tr '[:upper:]' '[:lower:]')
+
+# Original bundle prefix (e.g., com.appship.skeleton)
+ORIGINAL_BUNDLE="com.appship.${ORIGINAL_LOWER}"
+
+echo "=== Rename Template ==="
+echo "  From:      $ORIGINAL_NAME ($ORIGINAL_LOWER)"
+echo "  To:        $NEW_NAME ($NEW_LOWER)"
+echo "  Bundle:    $ORIGINAL_BUNDLE -> $BUNDLE_ID"
+echo "  Platform:  $PLATFORM"
+echo "  Directory: $APP_DIR"
+echo ""
+
+if [ ! -d "$APP_DIR" ]; then
+  echo "ERROR: App directory does not exist: $APP_DIR"
+  exit 1
+fi
+
+# ─── Helper: safe in-place sed (macOS + Linux compatible) ───────────────────
+replace_in_file() {
+  local file="$1"
+  local search="$2"
+  local replace="$3"
+  if [[ "$OSTYPE" == "darwin"* ]]; then
+    sed -i '' "s|${search}|${replace}|g" "$file"
+  else
+    sed -i "s|${search}|${replace}|g" "$file"
+  fi
+}
+
+# ─── Helper: replace in all text files recursively ──────────────────────────
+replace_in_all_files() {
+  local search="$1"
+  local replace="$2"
+  # Use find + grep to locate files containing the pattern, then sed
+  while IFS= read -r -d '' file; do
+    if file --mime "$file" 2>/dev/null | grep -q "text/"; then
+      if grep -q "$search" "$file" 2>/dev/null; then
+        replace_in_file "$file" "$search" "$replace"
+      fi
+    fi
+  done < <(find "$APP_DIR" -type f -print0 2>/dev/null)
+}
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# iOS RENAMING
+# ═══════════════════════════════════════════════════════════════════════════════
+if [ "$PLATFORM" = "ios" ]; then
+  echo "→ iOS: Renaming string references..."
+
+  # Replace bundle ID first (more specific)
+  replace_in_all_files "$ORIGINAL_BUNDLE" "$BUNDLE_ID"
+
+  # Replace PascalCase name (e.g., Skeleton -> PawSpa) in all files
+  replace_in_all_files "$ORIGINAL_NAME" "$NEW_NAME"
+
+  # Replace lowercase name where used (e.g., skeleton -> pawspa)
+  replace_in_all_files "$ORIGINAL_LOWER" "$NEW_LOWER"
+
+  echo "→ iOS: Renaming directories..."
+
+  # Rename the main source directory (e.g., Skeleton/ -> PawSpa/)
+  if [ -d "$APP_DIR/$ORIGINAL_NAME" ]; then
+    mv "$APP_DIR/$ORIGINAL_NAME" "$APP_DIR/$NEW_NAME"
+    echo "  Renamed $ORIGINAL_NAME/ -> $NEW_NAME/"
+  fi
+
+  # Rename the test directory (e.g., SkeletonTests/ -> PawSpaTests/)
+  if [ -d "$APP_DIR/${ORIGINAL_NAME}Tests" ]; then
+    mv "$APP_DIR/${ORIGINAL_NAME}Tests" "$APP_DIR/${NEW_NAME}Tests"
+    echo "  Renamed ${ORIGINAL_NAME}Tests/ -> ${NEW_NAME}Tests/"
+  fi
+
+  # Rename the app entry point file
+  if [ -f "$APP_DIR/$NEW_NAME/App/${ORIGINAL_NAME}App.swift" ]; then
+    mv "$APP_DIR/$NEW_NAME/App/${ORIGINAL_NAME}App.swift" "$APP_DIR/$NEW_NAME/App/${NEW_NAME}App.swift"
+    echo "  Renamed ${ORIGINAL_NAME}App.swift -> ${NEW_NAME}App.swift"
+  fi
+
+  # Rename .xcodeproj if it exists
+  if [ -d "$APP_DIR/$ORIGINAL_NAME.xcodeproj" ]; then
+    mv "$APP_DIR/$ORIGINAL_NAME.xcodeproj" "$APP_DIR/$NEW_NAME.xcodeproj"
+    echo "  Renamed $ORIGINAL_NAME.xcodeproj -> $NEW_NAME.xcodeproj"
+  fi
+
+  # Regenerate Xcode project with XcodeGen if project.yml exists
+  if [ -f "$APP_DIR/project.yml" ]; then
+    echo "→ iOS: Regenerating Xcode project..."
+    # Remove old .xcodeproj first (xcodegen creates a fresh one)
+    rm -rf "$APP_DIR/$NEW_NAME.xcodeproj" 2>/dev/null || true
+    if command -v xcodegen &>/dev/null; then
+      (cd "$APP_DIR" && xcodegen generate 2>&1) || echo "  WARNING: xcodegen failed — agent will handle it"
+    else
+      echo "  WARNING: xcodegen not found — agent will regenerate"
+    fi
+  fi
+
+  # Replace Maestro test placeholders
+  if [ -d "$APP_DIR/tests" ]; then
+    echo "→ iOS: Updating Maestro test bundle IDs..."
+    while IFS= read -r -d '' yamlFile; do
+      replace_in_file "$yamlFile" '\${APP_BUNDLE_ID}' "$BUNDLE_ID"
+      replace_in_file "$yamlFile" "$ORIGINAL_BUNDLE" "$BUNDLE_ID"
+      replace_in_file "$yamlFile" "$ORIGINAL_NAME" "$NEW_NAME"
+    done < <(find "$APP_DIR/tests" -name "*.yaml" -o -name "*.yml" -print0 2>/dev/null)
+  fi
+
+  echo "✓ iOS rename complete."
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# ANDROID RENAMING
+# ═══════════════════════════════════════════════════════════════════════════════
+elif [ "$PLATFORM" = "android" ]; then
+  echo "→ Android: Renaming string references..."
+
+  # Derive package path segments from bundle IDs
+  ORIGINAL_PKG_PATH=$(echo "$ORIGINAL_BUNDLE" | tr '.' '/')
+  NEW_PKG_PATH=$(echo "$BUNDLE_ID" | tr '.' '/')
+
+  # Replace bundle/package ID in all files (e.g., com.appship.skeleton -> com.appship.pawspa)
+  replace_in_all_files "$ORIGINAL_BUNDLE" "$BUNDLE_ID"
+
+  # Replace PascalCase name (e.g., Skeleton -> PawSpa) in all files
+  replace_in_all_files "${ORIGINAL_NAME}Application" "${NEW_NAME}Application"
+  replace_in_all_files "${ORIGINAL_NAME}Theme" "${NEW_NAME}Theme"
+  replace_in_all_files "$ORIGINAL_NAME" "$NEW_NAME"
+
+  echo "→ Android: Renaming package directories..."
+
+  # Rename main source package directories
+  for srcSet in main test androidTest; do
+    _src="$APP_DIR/app/src/$srcSet/kotlin/$ORIGINAL_PKG_PATH"
+    _dst="$APP_DIR/app/src/$srcSet/kotlin/$NEW_PKG_PATH"
+
+    if [ -d "$_src" ]; then
+      mkdir -p "$(dirname "$_dst")"
+      mv "$_src" "$_dst"
+      echo "  Renamed $srcSet kotlin/$ORIGINAL_PKG_PATH -> kotlin/$NEW_PKG_PATH"
+
+      # Clean up empty parent dirs from old path
+      _cleanup_dir="$APP_DIR/app/src/$srcSet/kotlin/$(echo "$ORIGINAL_BUNDLE" | cut -d. -f1-2 | tr '.' '/')"
+      if [ -d "$_cleanup_dir" ]; then
+        find "$_cleanup_dir" -type d -empty -delete 2>/dev/null || true
+      fi
+    fi
+  done
+
+  # Rename the Application class file
+  if [ -f "$APP_DIR/app/src/main/kotlin/$NEW_PKG_PATH/${ORIGINAL_NAME}Application.kt" ]; then
+    mv "$APP_DIR/app/src/main/kotlin/$NEW_PKG_PATH/${ORIGINAL_NAME}Application.kt" \
+       "$APP_DIR/app/src/main/kotlin/$NEW_PKG_PATH/${NEW_NAME}Application.kt"
+    echo "  Renamed ${ORIGINAL_NAME}Application.kt -> ${NEW_NAME}Application.kt"
+  fi
+
+  # Replace Maestro test placeholders
+  if [ -d "$APP_DIR/tests" ]; then
+    echo "→ Android: Updating Maestro test package names..."
+    while IFS= read -r -d '' yamlFile; do
+      replace_in_file "$yamlFile" '\${APP_PACKAGE_NAME}' "$BUNDLE_ID"
+      replace_in_file "$yamlFile" "$ORIGINAL_BUNDLE" "$BUNDLE_ID"
+      replace_in_file "$yamlFile" "$ORIGINAL_NAME" "$NEW_NAME"
+    done < <(find "$APP_DIR/tests" -name "*.yaml" -o -name "*.yml" -print0 2>/dev/null)
+  fi
+
+  echo "✓ Android rename complete."
+
+else
+  echo "ERROR: Unknown platform: $PLATFORM (expected 'ios' or 'android')"
+  exit 1
+fi
+
+# ─── Final verification ─────────────────────────────────────────────────────
+echo ""
+echo "→ Verification: checking for leftover '$ORIGINAL_NAME' references..."
+LEFTOVERS=$(grep -r "$ORIGINAL_NAME" "$APP_DIR" --include="*.swift" --include="*.kt" --include="*.kts" --include="*.xml" --include="*.yml" --include="*.yaml" --include="*.plist" --include="*.json" --exclude-dir="build" --exclude-dir=".build" --exclude-dir="Build" --exclude-dir="DerivedData" -l 2>/dev/null || true)
+if [ -n "$LEFTOVERS" ]; then
+  echo "  WARNING: Leftover references found in:"
+  echo "$LEFTOVERS" | head -20
+  echo "  (The agent should clean these up)"
+else
+  echo "  ✓ No leftover references found."
+fi
+
+echo ""
+echo "=== Rename complete ==="

package/scripts/run-maestro-ios.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+set -e
+TEMPLATES_DIR="/Users/shayco/AppAgent/templates/ios"
+SIM="1CF1D654-B6B0-42A2-B94C-2B3358E19E3E"
+
+for t in "$@"; do
+  dir="$TEMPLATES_DIR/$t"
+  bid="com.appship.$(echo "$t" | sed 's/Template//' | tr '[:upper:]' '[:lower:]')"
+  echo "=== $t ($bid) ==="
+  cd "$dir"
+  xcodegen generate 2>&1 | tail -1
+  xcodebuild -project "${t}.xcodeproj" -scheme "$t" -sdk iphonesimulator \
+    -destination "id=$SIM" -derivedDataPath build build 2>&1 | tail -2
+  APP=$(find build -name "${t}.app" -type d | head -1)
+  xcrun simctl install "$SIM" "$APP"
+  p=0; f=0
+  for y in tests/*.yaml; do
+    [ -f "$y" ] || continue
+    n=$(basename "$y")
+    OUT=$(maestro --device "$SIM" test -e APP_BUNDLE_ID="$bid" "$y" 2>&1)
+    if echo "$OUT" | grep -q "FAILED"; then
+      echo "  FAIL: $n"
+      echo "$OUT" | grep -B1 "FAILED" | head -4
+      f=$((f+1))
+    else
+      echo "  PASS: $n"
+      p=$((p+1))
+    fi
+  done
+  echo "RESULT: $t $p/$((p+f)) passed"
+  xcrun simctl uninstall "$SIM" "$bid" 2>/dev/null
+  echo ""
+done