1450 lines
55 KiB
Markdown
1450 lines
55 KiB
Markdown
# Clone App Skill Implementation Plan
|
||
|
||
> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
|
||
|
||
**Goal:** Build a `/clone-app` Claude Code skill that downloads an Android app's APK from a Google Play URL, reverse engineers it (via the existing `android-reverse-engineering` plugin), analyzes store presence, estimates AI-assisted clone effort + infra cost, produces a market-viability report, and optionally hands off to `writing-plans`.
|
||
|
||
**Architecture:** A new `clone-app` plugin living **inside the fork** of `masa2146/android-reverse-engineering-skill`, alongside the untouched upstream `android-reverse-engineering` plugin. The orchestrator `SKILL.md` drives 8 phases (0–7); deterministic steps (URL parsing, APK download, store scrape, package-name extraction) are factored into small standalone bash/python helper scripts that are unit-testable. The RE plugin's existing scripts are invoked directly by path. AI-judgment phases (stack recommendation, effort estimate, viability verdict) live as prose instructions + reference templates in the skill.
|
||
|
||
**Tech Stack:** Bash (helper scripts + glue), Python 3 (store scrape + JSON parsing where bash is too brittle), Markdown (skill/command/reference docs), `bats` or plain bash assertions for script tests, `curl`, the upstream RE scripts (jadx/Java).
|
||
|
||
## Global Constraints
|
||
|
||
- Repo root: `/Users/fatih.bulut/PythonWorks/clone_app_skill` (the cloned fork).
|
||
- Upstream plugin dir `plugins/android-reverse-engineering/` is **NEVER modified** — zero edits, to keep `git pull upstream master` conflict-free.
|
||
- New plugin dir: `plugins/clone-app/`.
|
||
- RE scripts are referenced via `${CLAUDE_PLUGIN_ROOT}` of the clone-app plugin, resolving sibling: `"$(dirname "$CLAUDE_PLUGIN_ROOT")/android-reverse-engineering/skills/android-reverse-engineering/scripts"`.
|
||
- All skill `${CLAUDE_PLUGIN_ROOT}` references use that exact env var (Claude Code sets it per-plugin).
|
||
- Working dir for runtime artifacts: `./work/{package}/` (relative to user's cwd, NOT inside the plugin).
|
||
- Package name regex (verbatim): `id=([a-zA-Z0-9._]+)`
|
||
- APKPure download URL (verbatim): `https://d.apkpure.com/b/APK/{PACKAGE}?version=latest`
|
||
- "AI Sprint" = one focused Claude Code session (~2-4 hours human review time). Use this unit everywhere; never calendar time.
|
||
- Bash scripts: `set -euo pipefail` at top, `#!/usr/bin/env bash` shebang.
|
||
- Python scripts: `#!/usr/bin/env python3`, stdlib only (no pip installs) — use `urllib`, `json`, `re`, `html.parser`.
|
||
- Report filename (verbatim): `clone-report-YYYY-MM-DD.md` where date is the run date.
|
||
|
||
---
|
||
|
||
## File Structure
|
||
|
||
**Plugin scaffold:**
|
||
- `plugins/clone-app/.claude-plugin/plugin.json` — plugin manifest
|
||
- `.claude-plugin/marketplace.json` — MODIFY: add clone-app entry (this is the only root-level shared file we touch; low conflict risk)
|
||
- `plugins/clone-app/skills/clone-app/SKILL.md` — orchestrator, all 8 phases
|
||
- `plugins/clone-app/commands/clone-app.md` — `/clone-app` slash command
|
||
|
||
**Helper scripts (deterministic, testable):**
|
||
- `plugins/clone-app/skills/clone-app/scripts/extract-package.sh` — Google Play URL → package name
|
||
- `plugins/clone-app/skills/clone-app/scripts/download-apk.sh` — APKPure download w/ retries + filetype detect
|
||
- `plugins/clone-app/skills/clone-app/scripts/resolve-re-scripts.sh` — locate sibling RE scripts dir, fail loud if absent
|
||
- `plugins/clone-app/skills/clone-app/scripts/scrape-play-store.py` — Google Play page → metrics JSON
|
||
- `plugins/clone-app/skills/clone-app/scripts/check-appstore.py` — iTunes Search API → iOS presence JSON
|
||
|
||
**Reference docs (AI-judgment guidance):**
|
||
- `plugins/clone-app/skills/clone-app/references/effort-estimation-guide.md` — how to build the AI-sprint table
|
||
- `plugins/clone-app/skills/clone-app/references/infra-cost-guide.md` — hosting/db/CDN cost heuristics
|
||
- `plugins/clone-app/skills/clone-app/references/report-template.md` — the clone-report skeleton
|
||
- `plugins/clone-app/skills/clone-app/references/stack-recommendation-guide.md` — how to pick/present 2-3 stacks
|
||
|
||
**Tests:**
|
||
- `plugins/clone-app/tests/test-extract-package.sh`
|
||
- `plugins/clone-app/tests/test-download-apk.sh`
|
||
- `plugins/clone-app/tests/test-resolve-re-scripts.sh`
|
||
- `plugins/clone-app/tests/test-scrape-play-store.py`
|
||
- `plugins/clone-app/tests/test-check-appstore.py`
|
||
- `plugins/clone-app/tests/fixtures/` — sample HTML/JSON fixtures
|
||
- `plugins/clone-app/tests/run-all.sh` — runs every test
|
||
|
||
**Docs:**
|
||
- `plugins/clone-app/README.md` — install + usage
|
||
|
||
---
|
||
|
||
## Task 1: Repo bootstrap + plugin scaffold
|
||
|
||
**Files:**
|
||
- Verify: `/Users/fatih.bulut/PythonWorks/clone_app_skill/` is the cloned fork with `plugins/android-reverse-engineering/` present
|
||
- Create: `plugins/clone-app/.claude-plugin/plugin.json`
|
||
- Modify: `.claude-plugin/marketplace.json` (add clone-app plugin entry)
|
||
|
||
**Interfaces:**
|
||
- Produces: a valid plugin discoverable by `/plugin install clone-app@android-reverse-engineering-skill`. Plugin name string: `clone-app`. Marketplace name string stays: `android-reverse-engineering-skill`.
|
||
|
||
- [ ] **Step 1: Verify the working dir is the cloned fork**
|
||
|
||
Run:
|
||
```bash
|
||
cd /Users/fatih.bulut/PythonWorks/clone_app_skill && \
|
||
ls plugins/android-reverse-engineering/skills/android-reverse-engineering/scripts/decompile.sh && \
|
||
git remote -v
|
||
```
|
||
Expected: the `decompile.sh` path lists successfully, and `git remote -v` shows an `origin` pointing at `masa2146/android-reverse-engineering-skill`.
|
||
|
||
If the directory is empty (fork not cloned yet), run:
|
||
```bash
|
||
cd /Users/fatih.bulut/PythonWorks && \
|
||
rm -rf clone_app_skill && \
|
||
git clone https://github.com/masa2146/android-reverse-engineering-skill.git clone_app_skill && \
|
||
cd clone_app_skill && \
|
||
git remote add upstream https://github.com/SimoneAvogadro/android-reverse-engineering-skill.git
|
||
```
|
||
Expected: clone succeeds, upstream remote added. Re-run the verify command above.
|
||
|
||
- [ ] **Step 2: Create the plugin manifest**
|
||
|
||
Create `plugins/clone-app/.claude-plugin/plugin.json`:
|
||
```json
|
||
{
|
||
"name": "clone-app",
|
||
"version": "0.1.0",
|
||
"description": "Analyze a Google Play app: download APK, reverse engineer it, estimate AI-assisted clone effort and infra cost, assess market viability, and optionally generate an implementation plan.",
|
||
"author": {
|
||
"name": "masa2146"
|
||
},
|
||
"repository": "https://github.com/masa2146/android-reverse-engineering-skill",
|
||
"license": "Apache-2.0",
|
||
"keywords": ["android", "clone", "feasibility", "effort-estimation", "market-analysis", "reverse-engineering"],
|
||
"skills": "./skills/",
|
||
"commands": "./commands/"
|
||
}
|
||
```
|
||
|
||
- [ ] **Step 3: Add clone-app to the marketplace catalog**
|
||
|
||
Read the current `.claude-plugin/marketplace.json`, then append a second object to the `plugins` array (keep the existing `android-reverse-engineering` entry untouched). The `plugins` array becomes:
|
||
```json
|
||
"plugins": [
|
||
{
|
||
"name": "android-reverse-engineering",
|
||
"source": "./plugins/android-reverse-engineering",
|
||
"description": "Decompile Android APK/JAR/AAR with jadx, trace call flows through libraries, and document extracted APIs.",
|
||
"version": "1.5.0",
|
||
"author": { "name": "Simone Avogadro" },
|
||
"repository": "https://github.com/SimoneAvogadro/android-reverse-engineering-skill",
|
||
"license": "Apache-2.0",
|
||
"keywords": ["android", "reverse-engineering", "apk", "jadx", "decompile", "api-extraction"],
|
||
"category": "security"
|
||
},
|
||
{
|
||
"name": "clone-app",
|
||
"source": "./plugins/clone-app",
|
||
"description": "Analyze a Google Play app for cloning: APK reverse engineering, AI-assisted effort estimation, market viability.",
|
||
"version": "0.1.0",
|
||
"author": { "name": "masa2146" },
|
||
"repository": "https://github.com/masa2146/android-reverse-engineering-skill",
|
||
"license": "Apache-2.0",
|
||
"keywords": ["android", "clone", "feasibility", "effort-estimation", "market-analysis"],
|
||
"category": "security"
|
||
}
|
||
]
|
||
```
|
||
|
||
- [ ] **Step 4: Validate JSON**
|
||
|
||
Run:
|
||
```bash
|
||
cd /Users/fatih.bulut/PythonWorks/clone_app_skill && \
|
||
python3 -c "import json; json.load(open('plugins/clone-app/.claude-plugin/plugin.json')); json.load(open('.claude-plugin/marketplace.json')); print('OK')"
|
||
```
|
||
Expected: `OK`
|
||
|
||
- [ ] **Step 5: Commit**
|
||
|
||
```bash
|
||
cd /Users/fatih.bulut/PythonWorks/clone_app_skill && \
|
||
git add plugins/clone-app/.claude-plugin/plugin.json .claude-plugin/marketplace.json && \
|
||
git commit -m "feat(clone-app): scaffold plugin manifest and marketplace entry"
|
||
```
|
||
|
||
---
|
||
|
||
## Task 2: `extract-package.sh` — Google Play URL → package name
|
||
|
||
**Files:**
|
||
- Create: `plugins/clone-app/skills/clone-app/scripts/extract-package.sh`
|
||
- Test: `plugins/clone-app/tests/test-extract-package.sh`
|
||
|
||
**Interfaces:**
|
||
- Produces: `extract-package.sh <url-or-package>` prints the bare package name to stdout, exit 0. On no match, prints nothing to stdout, writes `ERROR: could not extract package` to stderr, exit 1. Accepts either a full Play URL or an already-bare package name (passthrough if it matches `^[a-zA-Z0-9._]+$` with a dot).
|
||
|
||
- [ ] **Step 1: Write the failing test**
|
||
|
||
Create `plugins/clone-app/tests/test-extract-package.sh`:
|
||
```bash
|
||
#!/usr/bin/env bash
|
||
set -uo pipefail
|
||
SCRIPT="$(dirname "$0")/../skills/clone-app/scripts/extract-package.sh"
|
||
fail=0
|
||
check() {
|
||
local desc="$1" expected="$2" actual="$3"
|
||
if [[ "$expected" == "$actual" ]]; then
|
||
echo "PASS: $desc"
|
||
else
|
||
echo "FAIL: $desc — expected '$expected' got '$actual'"; fail=1
|
||
fi
|
||
}
|
||
|
||
check "full url" "com.example.app" \
|
||
"$(bash "$SCRIPT" 'https://play.google.com/store/apps/details?id=com.example.app')"
|
||
check "url with extra params" "com.whatsapp" \
|
||
"$(bash "$SCRIPT" 'https://play.google.com/store/apps/details?id=com.whatsapp&hl=en&gl=US')"
|
||
check "bare package passthrough" "com.spotify.music" \
|
||
"$(bash "$SCRIPT" 'com.spotify.music')"
|
||
|
||
# invalid input → exit 1, empty stdout
|
||
out="$(bash "$SCRIPT" 'not a url' 2>/dev/null)"; rc=$?
|
||
check "invalid exit code" "1" "$rc"
|
||
check "invalid empty stdout" "" "$out"
|
||
|
||
exit $fail
|
||
```
|
||
|
||
- [ ] **Step 2: Run test to verify it fails**
|
||
|
||
Run:
|
||
```bash
|
||
bash /Users/fatih.bulut/PythonWorks/clone_app_skill/plugins/clone-app/tests/test-extract-package.sh
|
||
```
|
||
Expected: FAIL (script does not exist yet — `bash: ...extract-package.sh: No such file or directory`).
|
||
|
||
- [ ] **Step 3: Write minimal implementation**
|
||
|
||
Create `plugins/clone-app/skills/clone-app/scripts/extract-package.sh`:
|
||
```bash
|
||
#!/usr/bin/env bash
|
||
set -euo pipefail
|
||
|
||
input="${1:-}"
|
||
if [[ -z "$input" ]]; then
|
||
echo "ERROR: usage: extract-package.sh <play-url-or-package>" >&2
|
||
exit 1
|
||
fi
|
||
|
||
# Case 1: full URL containing id=<package>
|
||
if [[ "$input" =~ id=([a-zA-Z0-9._]+) ]]; then
|
||
echo "${BASH_REMATCH[1]}"
|
||
exit 0
|
||
fi
|
||
|
||
# Case 2: already a bare package (must contain a dot, valid chars only)
|
||
if [[ "$input" =~ ^[a-zA-Z0-9_]+(\.[a-zA-Z0-9_]+)+$ ]]; then
|
||
echo "$input"
|
||
exit 0
|
||
fi
|
||
|
||
echo "ERROR: could not extract package from '$input'" >&2
|
||
exit 1
|
||
```
|
||
|
||
- [ ] **Step 4: Run test to verify it passes**
|
||
|
||
Run:
|
||
```bash
|
||
chmod +x /Users/fatih.bulut/PythonWorks/clone_app_skill/plugins/clone-app/skills/clone-app/scripts/extract-package.sh && \
|
||
bash /Users/fatih.bulut/PythonWorks/clone_app_skill/plugins/clone-app/tests/test-extract-package.sh
|
||
```
|
||
Expected: all `PASS`, exit 0.
|
||
|
||
- [ ] **Step 5: Commit**
|
||
|
||
```bash
|
||
cd /Users/fatih.bulut/PythonWorks/clone_app_skill && \
|
||
git add plugins/clone-app/skills/clone-app/scripts/extract-package.sh plugins/clone-app/tests/test-extract-package.sh && \
|
||
git commit -m "feat(clone-app): add extract-package.sh URL parser with tests"
|
||
```
|
||
|
||
---
|
||
|
||
## Task 3: `resolve-re-scripts.sh` — locate sibling RE scripts dir
|
||
|
||
**Files:**
|
||
- Create: `plugins/clone-app/skills/clone-app/scripts/resolve-re-scripts.sh`
|
||
- Test: `plugins/clone-app/tests/test-resolve-re-scripts.sh`
|
||
|
||
**Interfaces:**
|
||
- Consumes: env var `CLAUDE_PLUGIN_ROOT` (path to the clone-app plugin dir). Falls back to deriving its own location from `$0` if the env var is unset (so it works when run standalone in tests).
|
||
- Produces: `resolve-re-scripts.sh` prints the absolute path to the RE `scripts/` dir to stdout, exit 0. If that dir doesn't exist, writes a clear error naming the install command to stderr, exit 1.
|
||
|
||
- [ ] **Step 1: Write the failing test**
|
||
|
||
Create `plugins/clone-app/tests/test-resolve-re-scripts.sh`:
|
||
```bash
|
||
#!/usr/bin/env bash
|
||
set -uo pipefail
|
||
SCRIPT="$(dirname "$0")/../skills/clone-app/scripts/resolve-re-scripts.sh"
|
||
fail=0
|
||
check() { [[ "$2" == "$3" ]] && echo "PASS: $1" || { echo "FAIL: $1 — expected '$2' got '$3'"; fail=1; }; }
|
||
|
||
# In the real repo layout, the RE scripts dir exists as a sibling plugin.
|
||
out="$(bash "$SCRIPT" 2>/dev/null)"; rc=$?
|
||
check "exit 0 when RE present" "0" "$rc"
|
||
check "ends with scripts dir" "android-reverse-engineering/skills/android-reverse-engineering/scripts" \
|
||
"$(basename "$(dirname "$(dirname "$(dirname "$out")")")")/$(basename "$(dirname "$(dirname "$out")")")/$(basename "$(dirname "$out")")/$(basename "$out")"
|
||
check "decompile.sh exists under resolved dir" "yes" \
|
||
"$([[ -f "$out/decompile.sh" ]] && echo yes || echo no)"
|
||
|
||
# When CLAUDE_PLUGIN_ROOT points somewhere with no sibling RE plugin → exit 1
|
||
tmp="$(mktemp -d)"
|
||
out2="$(CLAUDE_PLUGIN_ROOT="$tmp/clone-app" bash "$SCRIPT" 2>/dev/null)"; rc2=$?
|
||
check "exit 1 when RE missing" "1" "$rc2"
|
||
rm -rf "$tmp"
|
||
|
||
exit $fail
|
||
```
|
||
|
||
- [ ] **Step 2: Run test to verify it fails**
|
||
|
||
Run:
|
||
```bash
|
||
bash /Users/fatih.bulut/PythonWorks/clone_app_skill/plugins/clone-app/tests/test-resolve-re-scripts.sh
|
||
```
|
||
Expected: FAIL (script missing).
|
||
|
||
- [ ] **Step 3: Write minimal implementation**
|
||
|
||
Create `plugins/clone-app/skills/clone-app/scripts/resolve-re-scripts.sh`:
|
||
```bash
|
||
#!/usr/bin/env bash
|
||
set -euo pipefail
|
||
|
||
# Determine this plugin's root. Prefer the env var Claude Code sets; fall back
|
||
# to deriving from this script's own location (…/clone-app/skills/clone-app/scripts).
|
||
if [[ -n "${CLAUDE_PLUGIN_ROOT:-}" ]]; then
|
||
plugin_root="$CLAUDE_PLUGIN_ROOT"
|
||
else
|
||
script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
|
||
# scripts -> clone-app -> skills -> clone-app(plugin root)
|
||
plugin_root="$(cd "$script_dir/../../.." && pwd)"
|
||
fi
|
||
|
||
# Sibling RE plugin lives next to clone-app under plugins/
|
||
re_scripts="$(cd "$plugin_root/.." 2>/dev/null && pwd)/android-reverse-engineering/skills/android-reverse-engineering/scripts"
|
||
|
||
if [[ ! -d "$re_scripts" ]]; then
|
||
echo "ERROR: android-reverse-engineering scripts not found at: $re_scripts" >&2
|
||
echo "Install it: /plugin install android-reverse-engineering@android-reverse-engineering-skill" >&2
|
||
exit 1
|
||
fi
|
||
|
||
echo "$re_scripts"
|
||
```
|
||
|
||
- [ ] **Step 4: Run test to verify it passes**
|
||
|
||
Run:
|
||
```bash
|
||
chmod +x /Users/fatih.bulut/PythonWorks/clone_app_skill/plugins/clone-app/skills/clone-app/scripts/resolve-re-scripts.sh && \
|
||
bash /Users/fatih.bulut/PythonWorks/clone_app_skill/plugins/clone-app/tests/test-resolve-re-scripts.sh
|
||
```
|
||
Expected: all `PASS`, exit 0.
|
||
|
||
- [ ] **Step 5: Commit**
|
||
|
||
```bash
|
||
cd /Users/fatih.bulut/PythonWorks/clone_app_skill && \
|
||
git add plugins/clone-app/skills/clone-app/scripts/resolve-re-scripts.sh plugins/clone-app/tests/test-resolve-re-scripts.sh && \
|
||
git commit -m "feat(clone-app): add resolve-re-scripts.sh sibling-plugin locator with tests"
|
||
```
|
||
|
||
---
|
||
|
||
## Task 4: `download-apk.sh` — APKPure download with retries + filetype detect
|
||
|
||
**Files:**
|
||
- Create: `plugins/clone-app/skills/clone-app/scripts/download-apk.sh`
|
||
- Test: `plugins/clone-app/tests/test-download-apk.sh`
|
||
|
||
**Interfaces:**
|
||
- Consumes: `download-apk.sh <package> <out-dir>` and optional env `CLONE_APP_CURL` (override curl binary, used by test to inject a stub).
|
||
- Produces: downloads to `<out-dir>/app.<ext>` where ext is `xapk` or `apk` decided by magic bytes (ZIP `PK\x03\x04` for both; distinguish by presence of `manifest.json` + multiple `.apk` entries → xapk, else apk). Prints the final file path to stdout on success, exit 0. Retries up to 3 times on curl failure. On total failure: stderr message, exit 1.
|
||
|
||
- [ ] **Step 1: Write the failing test**
|
||
|
||
Create `plugins/clone-app/tests/test-download-apk.sh`:
|
||
```bash
|
||
#!/usr/bin/env bash
|
||
set -uo pipefail
|
||
SCRIPT="$(dirname "$0")/../skills/clone-app/scripts/download-apk.sh"
|
||
fail=0
|
||
check() { [[ "$2" == "$3" ]] && echo "PASS: $1" || { echo "FAIL: $1 — expected '$2' got '$3'"; fail=1; }; }
|
||
|
||
tmp="$(mktemp -d)"
|
||
|
||
# Stub curl: writes a minimal zip containing manifest.json + two apk entries → xapk
|
||
cat > "$tmp/fakecurl-xapk.sh" <<'EOF'
|
||
#!/usr/bin/env bash
|
||
out=""; prev=""
|
||
for a in "$@"; do [[ "$prev" == "--output" ]] && out="$a"; prev="$a"; done
|
||
workdir="$(mktemp -d)"
|
||
echo '{}' > "$workdir/manifest.json"
|
||
echo 'a' > "$workdir/base.apk"; echo 'b' > "$workdir/config.apk"
|
||
( cd "$workdir" && zip -q -r "$out" . )
|
||
exit 0
|
||
EOF
|
||
chmod +x "$tmp/fakecurl-xapk.sh"
|
||
|
||
path="$(CLONE_APP_CURL="$tmp/fakecurl-xapk.sh" bash "$SCRIPT" com.example.app "$tmp/out" 2>/dev/null)"; rc=$?
|
||
check "xapk exit 0" "0" "$rc"
|
||
check "xapk extension" "xapk" "${path##*.}"
|
||
|
||
# Stub curl that always fails → exit 1 after retries
|
||
cat > "$tmp/fakecurl-fail.sh" <<'EOF'
|
||
#!/usr/bin/env bash
|
||
exit 22
|
||
EOF
|
||
chmod +x "$tmp/fakecurl-fail.sh"
|
||
out2="$(CLONE_APP_CURL="$tmp/fakecurl-fail.sh" bash "$SCRIPT" com.example.app "$tmp/out2" 2>/dev/null)"; rc2=$?
|
||
check "fail exit 1" "1" "$rc2"
|
||
|
||
rm -rf "$tmp"
|
||
exit $fail
|
||
```
|
||
|
||
- [ ] **Step 2: Run test to verify it fails**
|
||
|
||
Run:
|
||
```bash
|
||
bash /Users/fatih.bulut/PythonWorks/clone_app_skill/plugins/clone-app/tests/test-download-apk.sh
|
||
```
|
||
Expected: FAIL (script missing).
|
||
|
||
- [ ] **Step 3: Write minimal implementation**
|
||
|
||
Create `plugins/clone-app/skills/clone-app/scripts/download-apk.sh`:
|
||
```bash
|
||
#!/usr/bin/env bash
|
||
set -euo pipefail
|
||
|
||
package="${1:-}"
|
||
out_dir="${2:-}"
|
||
curl_bin="${CLONE_APP_CURL:-curl}"
|
||
|
||
if [[ -z "$package" || -z "$out_dir" ]]; then
|
||
echo "ERROR: usage: download-apk.sh <package> <out-dir>" >&2
|
||
exit 1
|
||
fi
|
||
|
||
mkdir -p "$out_dir"
|
||
tmp_file="$out_dir/app.download"
|
||
url="https://d.apkpure.com/b/APK/${package}?version=latest"
|
||
|
||
ok=0
|
||
for attempt in 1 2 3; do
|
||
if "$curl_bin" -L --fail "$url" --output "$tmp_file" 2>/dev/null; then
|
||
ok=1; break
|
||
fi
|
||
echo "download attempt $attempt failed, retrying..." >&2
|
||
sleep 1
|
||
done
|
||
|
||
if [[ "$ok" -ne 1 ]]; then
|
||
echo "ERROR: failed to download $package after 3 attempts from $url" >&2
|
||
rm -f "$tmp_file"
|
||
exit 1
|
||
fi
|
||
|
||
# Decide extension: both APK and XAPK are ZIPs. XAPK = zip containing manifest.json + >=2 .apk entries.
|
||
ext="apk"
|
||
if entries="$(unzip -Z1 "$tmp_file" 2>/dev/null)"; then
|
||
apk_count="$(grep -c '\.apk$' <<<"$entries" || true)"
|
||
if grep -q '^manifest\.json$' <<<"$entries" && [[ "$apk_count" -ge 1 ]]; then
|
||
ext="xapk"
|
||
fi
|
||
fi
|
||
|
||
final="$out_dir/app.$ext"
|
||
mv "$tmp_file" "$final"
|
||
echo "$final"
|
||
```
|
||
|
||
- [ ] **Step 4: Run test to verify it passes**
|
||
|
||
Run:
|
||
```bash
|
||
chmod +x /Users/fatih.bulut/PythonWorks/clone_app_skill/plugins/clone-app/skills/clone-app/scripts/download-apk.sh && \
|
||
bash /Users/fatih.bulut/PythonWorks/clone_app_skill/plugins/clone-app/tests/test-download-apk.sh
|
||
```
|
||
Expected: all `PASS`, exit 0. (Requires `zip`/`unzip` available — standard on macOS.)
|
||
|
||
- [ ] **Step 5: Commit**
|
||
|
||
```bash
|
||
cd /Users/fatih.bulut/PythonWorks/clone_app_skill && \
|
||
git add plugins/clone-app/skills/clone-app/scripts/download-apk.sh plugins/clone-app/tests/test-download-apk.sh && \
|
||
git commit -m "feat(clone-app): add download-apk.sh with retries and xapk/apk detection"
|
||
```
|
||
|
||
---
|
||
|
||
## Task 5: `scrape-play-store.py` — Google Play page → metrics JSON
|
||
|
||
**Files:**
|
||
- Create: `plugins/clone-app/skills/clone-app/scripts/scrape-play-store.py`
|
||
- Create: `plugins/clone-app/tests/fixtures/play-sample.html`
|
||
- Test: `plugins/clone-app/tests/test-scrape-play-store.py`
|
||
|
||
**Interfaces:**
|
||
- Consumes: `scrape-play-store.py <package>` fetches `https://play.google.com/store/apps/details?id=<package>&hl=en&gl=US`. For testing, `--html-file <path>` reads local HTML instead of network.
|
||
- Produces: prints a JSON object to stdout with keys: `package` (str), `title` (str|null), `rating` (float|null), `rating_count` (int|null), `installs` (str|null), `category` (str|null), `developer` (str|null), `updated` (str|null), `source` (str: "google-play"). Missing fields are `null`, never absent. Exit 0 even on partial extraction; exit 1 only on fetch error (network/HTTP) when not using `--html-file`.
|
||
|
||
- [ ] **Step 1: Create the test fixture**
|
||
|
||
Create `plugins/clone-app/tests/fixtures/play-sample.html` — a trimmed but realistic Play page. Include the data-bearing markup the scraper targets:
|
||
```html
|
||
<!DOCTYPE html>
|
||
<html><head><title>Example App - Apps on Google Play</title>
|
||
<script type="application/ld+json">
|
||
{"@type":"SoftwareApplication","name":"Example App","author":{"name":"Example Studio"},
|
||
"aggregateRating":{"ratingValue":"4.3","ratingCount":"12873"},
|
||
"applicationCategory":"GAME_PUZZLE"}
|
||
</script>
|
||
</head><body>
|
||
<div>Updated on<span>Jun 1, 2026</span></div>
|
||
<div>1,000,000+<span>Downloads</span></div>
|
||
</body></html>
|
||
```
|
||
|
||
- [ ] **Step 2: Write the failing test**
|
||
|
||
Create `plugins/clone-app/tests/test-scrape-play-store.py`:
|
||
```python
|
||
#!/usr/bin/env python3
|
||
import json, subprocess, sys, os
|
||
|
||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||
SCRIPT = os.path.join(HERE, "..", "skills", "clone-app", "scripts", "scrape-play-store.py")
|
||
FIXTURE = os.path.join(HERE, "fixtures", "play-sample.html")
|
||
|
||
def run():
|
||
out = subprocess.check_output(
|
||
[sys.executable, SCRIPT, "com.example.app", "--html-file", FIXTURE])
|
||
return json.loads(out)
|
||
|
||
def main():
|
||
d = run()
|
||
fails = []
|
||
def check(name, cond):
|
||
print(f"{'PASS' if cond else 'FAIL'}: {name}")
|
||
if not cond: fails.append(name)
|
||
check("package", d["package"] == "com.example.app")
|
||
check("title", d["title"] == "Example App")
|
||
check("rating", abs((d["rating"] or 0) - 4.3) < 0.001)
|
||
check("rating_count", d["rating_count"] == 12873)
|
||
check("developer", d["developer"] == "Example Studio")
|
||
check("category", d["category"] == "GAME_PUZZLE")
|
||
check("installs", d["installs"] == "1,000,000+")
|
||
check("source", d["source"] == "google-play")
|
||
# all expected keys present even if null
|
||
for k in ["package","title","rating","rating_count","installs","category","developer","updated","source"]:
|
||
check(f"key present: {k}", k in d)
|
||
sys.exit(1 if fails else 0)
|
||
|
||
main()
|
||
```
|
||
|
||
- [ ] **Step 3: Run test to verify it fails**
|
||
|
||
Run:
|
||
```bash
|
||
python3 /Users/fatih.bulut/PythonWorks/clone_app_skill/plugins/clone-app/tests/test-scrape-play-store.py
|
||
```
|
||
Expected: FAIL (script missing — `FileNotFoundError` / non-zero exit).
|
||
|
||
- [ ] **Step 4: Write minimal implementation**
|
||
|
||
Create `plugins/clone-app/skills/clone-app/scripts/scrape-play-store.py`:
|
||
```python
|
||
#!/usr/bin/env python3
|
||
"""Scrape a Google Play store page into a metrics JSON object.
|
||
|
||
Primary source is the embedded ld+json SoftwareApplication block (stable).
|
||
Falls back to light regex for installs/updated which aren't always in ld+json.
|
||
"""
|
||
import sys, json, re, argparse, urllib.request
|
||
|
||
KEYS = ["package", "title", "rating", "rating_count", "installs",
|
||
"category", "developer", "updated", "source"]
|
||
|
||
def fetch(package):
|
||
url = f"https://play.google.com/store/apps/details?id={package}&hl=en&gl=US"
|
||
req = urllib.request.Request(url, headers={"User-Agent": "Mozilla/5.0"})
|
||
with urllib.request.urlopen(req, timeout=30) as r:
|
||
return r.read().decode("utf-8", "replace")
|
||
|
||
def parse(html, package):
|
||
out = {k: None for k in KEYS}
|
||
out["package"] = package
|
||
out["source"] = "google-play"
|
||
|
||
# ld+json SoftwareApplication block
|
||
for m in re.finditer(r'<script type="application/ld\+json">(.*?)</script>',
|
||
html, re.DOTALL):
|
||
try:
|
||
data = json.loads(m.group(1).strip())
|
||
except Exception:
|
||
continue
|
||
if isinstance(data, dict) and data.get("@type") == "SoftwareApplication":
|
||
out["title"] = data.get("name")
|
||
auth = data.get("author")
|
||
if isinstance(auth, dict):
|
||
out["developer"] = auth.get("name")
|
||
out["category"] = data.get("applicationCategory")
|
||
ar = data.get("aggregateRating") or {}
|
||
if ar.get("ratingValue") is not None:
|
||
try: out["rating"] = float(ar["ratingValue"])
|
||
except Exception: pass
|
||
if ar.get("ratingCount") is not None:
|
||
try: out["rating_count"] = int(ar["ratingCount"])
|
||
except Exception: pass
|
||
break
|
||
|
||
# installs (e.g. "1,000,000+")
|
||
m = re.search(r'([\d,]+\+)\s*<span>\s*Downloads', html)
|
||
if m:
|
||
out["installs"] = m.group(1)
|
||
|
||
# updated date (e.g. "Updated on<span>Jun 1, 2026</span>")
|
||
m = re.search(r'Updated on\s*<span>([^<]+)</span>', html)
|
||
if m:
|
||
out["updated"] = m.group(1).strip()
|
||
|
||
return out
|
||
|
||
def main():
|
||
ap = argparse.ArgumentParser()
|
||
ap.add_argument("package")
|
||
ap.add_argument("--html-file")
|
||
args = ap.parse_args()
|
||
|
||
if args.html_file:
|
||
with open(args.html_file, encoding="utf-8") as f:
|
||
html = f.read()
|
||
else:
|
||
try:
|
||
html = fetch(args.package)
|
||
except Exception as e:
|
||
print(f"ERROR: failed to fetch Play page: {e}", file=sys.stderr)
|
||
sys.exit(1)
|
||
|
||
print(json.dumps(parse(html, args.package), indent=2))
|
||
|
||
if __name__ == "__main__":
|
||
main()
|
||
```
|
||
|
||
- [ ] **Step 5: Run test to verify it passes**
|
||
|
||
Run:
|
||
```bash
|
||
python3 /Users/fatih.bulut/PythonWorks/clone_app_skill/plugins/clone-app/tests/test-scrape-play-store.py
|
||
```
|
||
Expected: all `PASS`, exit 0.
|
||
|
||
- [ ] **Step 6: Commit**
|
||
|
||
```bash
|
||
cd /Users/fatih.bulut/PythonWorks/clone_app_skill && \
|
||
git add plugins/clone-app/skills/clone-app/scripts/scrape-play-store.py \
|
||
plugins/clone-app/tests/test-scrape-play-store.py \
|
||
plugins/clone-app/tests/fixtures/play-sample.html && \
|
||
git commit -m "feat(clone-app): add scrape-play-store.py with ld+json parsing and tests"
|
||
```
|
||
|
||
---
|
||
|
||
## Task 6: `check-appstore.py` — iOS presence via iTunes Search API
|
||
|
||
**Files:**
|
||
- Create: `plugins/clone-app/skills/clone-app/scripts/check-appstore.py`
|
||
- Create: `plugins/clone-app/tests/fixtures/itunes-sample.json`
|
||
- Test: `plugins/clone-app/tests/test-check-appstore.py`
|
||
|
||
**Interfaces:**
|
||
- Consumes: `check-appstore.py <search-term>` queries `https://itunes.apple.com/search?term=<term>&entity=software&limit=5`. For testing, `--json-file <path>` reads a local iTunes response instead of network. (Note: there is no Android package → App Store ID mapping; we search by app title/term, best-effort.)
|
||
- Produces: prints JSON to stdout: `{ "found": bool, "source": "app-store", "results": [ {"name","seller","rating","rating_count","price","url"} ... ] }`. On network error without `--json-file`: still prints `{"found": false, "source":"app-store", "results": [], "error": "..."}` and exit 0 (App Store absence is non-fatal per spec).
|
||
|
||
- [ ] **Step 1: Create the test fixture**
|
||
|
||
Create `plugins/clone-app/tests/fixtures/itunes-sample.json`:
|
||
```json
|
||
{
|
||
"resultCount": 1,
|
||
"results": [
|
||
{
|
||
"trackName": "Example App",
|
||
"sellerName": "Example Studio",
|
||
"averageUserRating": 4.5,
|
||
"userRatingCount": 8421,
|
||
"formattedPrice": "Free",
|
||
"trackViewUrl": "https://apps.apple.com/app/id123456789"
|
||
}
|
||
]
|
||
}
|
||
```
|
||
|
||
- [ ] **Step 2: Write the failing test**
|
||
|
||
Create `plugins/clone-app/tests/test-check-appstore.py`:
|
||
```python
|
||
#!/usr/bin/env python3
|
||
import json, subprocess, sys, os
|
||
|
||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||
SCRIPT = os.path.join(HERE, "..", "skills", "clone-app", "scripts", "check-appstore.py")
|
||
FIXTURE = os.path.join(HERE, "fixtures", "itunes-sample.json")
|
||
|
||
def main():
|
||
out = subprocess.check_output(
|
||
[sys.executable, SCRIPT, "Example App", "--json-file", FIXTURE])
|
||
d = json.loads(out)
|
||
fails = []
|
||
def check(name, cond):
|
||
print(f"{'PASS' if cond else 'FAIL'}: {name}")
|
||
if not cond: fails.append(name)
|
||
check("found true", d["found"] is True)
|
||
check("source", d["source"] == "app-store")
|
||
check("one result", len(d["results"]) == 1)
|
||
r = d["results"][0]
|
||
check("name", r["name"] == "Example App")
|
||
check("seller", r["seller"] == "Example Studio")
|
||
check("rating", abs(r["rating"] - 4.5) < 0.001)
|
||
check("rating_count", r["rating_count"] == 8421)
|
||
check("price", r["price"] == "Free")
|
||
check("url", r["url"].endswith("id123456789"))
|
||
sys.exit(1 if fails else 0)
|
||
|
||
main()
|
||
```
|
||
|
||
- [ ] **Step 3: Run test to verify it fails**
|
||
|
||
Run:
|
||
```bash
|
||
python3 /Users/fatih.bulut/PythonWorks/clone_app_skill/plugins/clone-app/tests/test-check-appstore.py
|
||
```
|
||
Expected: FAIL (script missing).
|
||
|
||
- [ ] **Step 4: Write minimal implementation**
|
||
|
||
Create `plugins/clone-app/skills/clone-app/scripts/check-appstore.py`:
|
||
```python
|
||
#!/usr/bin/env python3
|
||
"""Best-effort check whether an iOS App Store equivalent exists, via the
|
||
public iTunes Search API. There is no reliable Android-package → App-Store-ID
|
||
mapping, so we search by term (app title) and return the top matches."""
|
||
import sys, json, argparse, urllib.request, urllib.parse
|
||
|
||
def fetch(term):
|
||
q = urllib.parse.urlencode({"term": term, "entity": "software", "limit": 5})
|
||
url = f"https://itunes.apple.com/search?{q}"
|
||
req = urllib.request.Request(url, headers={"User-Agent": "Mozilla/5.0"})
|
||
with urllib.request.urlopen(req, timeout=30) as r:
|
||
return json.loads(r.read().decode("utf-8", "replace"))
|
||
|
||
def shape(data):
|
||
results = []
|
||
for r in data.get("results", []):
|
||
results.append({
|
||
"name": r.get("trackName"),
|
||
"seller": r.get("sellerName"),
|
||
"rating": r.get("averageUserRating"),
|
||
"rating_count": r.get("userRatingCount"),
|
||
"price": r.get("formattedPrice"),
|
||
"url": r.get("trackViewUrl"),
|
||
})
|
||
return {"found": len(results) > 0, "source": "app-store", "results": results}
|
||
|
||
def main():
|
||
ap = argparse.ArgumentParser()
|
||
ap.add_argument("term")
|
||
ap.add_argument("--json-file")
|
||
args = ap.parse_args()
|
||
|
||
if args.json_file:
|
||
with open(args.json_file, encoding="utf-8") as f:
|
||
data = json.load(f)
|
||
else:
|
||
try:
|
||
data = fetch(args.term)
|
||
except Exception as e:
|
||
print(json.dumps({"found": False, "source": "app-store",
|
||
"results": [], "error": str(e)}, indent=2))
|
||
sys.exit(0)
|
||
|
||
print(json.dumps(shape(data), indent=2))
|
||
|
||
if __name__ == "__main__":
|
||
main()
|
||
```
|
||
|
||
- [ ] **Step 5: Run test to verify it passes**
|
||
|
||
Run:
|
||
```bash
|
||
python3 /Users/fatih.bulut/PythonWorks/clone_app_skill/plugins/clone-app/tests/test-check-appstore.py
|
||
```
|
||
Expected: all `PASS`, exit 0.
|
||
|
||
- [ ] **Step 6: Commit**
|
||
|
||
```bash
|
||
cd /Users/fatih.bulut/PythonWorks/clone_app_skill && \
|
||
git add plugins/clone-app/skills/clone-app/scripts/check-appstore.py \
|
||
plugins/clone-app/tests/test-check-appstore.py \
|
||
plugins/clone-app/tests/fixtures/itunes-sample.json && \
|
||
git commit -m "feat(clone-app): add check-appstore.py iTunes search with tests"
|
||
```
|
||
|
||
---
|
||
|
||
## Task 7: Test runner aggregator
|
||
|
||
**Files:**
|
||
- Create: `plugins/clone-app/tests/run-all.sh`
|
||
|
||
**Interfaces:**
|
||
- Produces: `run-all.sh` runs every test (bash + python), prints a summary, exits non-zero if any fail.
|
||
|
||
- [ ] **Step 1: Write the runner**
|
||
|
||
Create `plugins/clone-app/tests/run-all.sh`:
|
||
```bash
|
||
#!/usr/bin/env bash
|
||
set -uo pipefail
|
||
HERE="$(cd "$(dirname "$0")" && pwd)"
|
||
fail=0
|
||
|
||
echo "=== bash tests ==="
|
||
for t in "$HERE"/test-*.sh; do
|
||
echo "--- $(basename "$t") ---"
|
||
bash "$t" || fail=1
|
||
done
|
||
|
||
echo "=== python tests ==="
|
||
for t in "$HERE"/test-*.py; do
|
||
echo "--- $(basename "$t") ---"
|
||
python3 "$t" || fail=1
|
||
done
|
||
|
||
echo
|
||
if [[ "$fail" -eq 0 ]]; then echo "ALL TESTS PASSED"; else echo "SOME TESTS FAILED"; fi
|
||
exit $fail
|
||
```
|
||
|
||
- [ ] **Step 2: Run it**
|
||
|
||
Run:
|
||
```bash
|
||
chmod +x /Users/fatih.bulut/PythonWorks/clone_app_skill/plugins/clone-app/tests/run-all.sh && \
|
||
bash /Users/fatih.bulut/PythonWorks/clone_app_skill/plugins/clone-app/tests/run-all.sh
|
||
```
|
||
Expected: `ALL TESTS PASSED`, exit 0 (all of Tasks 2–6 green).
|
||
|
||
- [ ] **Step 3: Commit**
|
||
|
||
```bash
|
||
cd /Users/fatih.bulut/PythonWorks/clone_app_skill && \
|
||
git add plugins/clone-app/tests/run-all.sh && \
|
||
git commit -m "test(clone-app): add aggregate test runner"
|
||
```
|
||
|
||
---
|
||
|
||
## Task 8: Reference docs — effort, infra cost, stack, report template
|
||
|
||
**Files:**
|
||
- Create: `plugins/clone-app/skills/clone-app/references/stack-recommendation-guide.md`
|
||
- Create: `plugins/clone-app/skills/clone-app/references/effort-estimation-guide.md`
|
||
- Create: `plugins/clone-app/skills/clone-app/references/infra-cost-guide.md`
|
||
- Create: `plugins/clone-app/skills/clone-app/references/report-template.md`
|
||
|
||
**Interfaces:**
|
||
- Produces: four reference docs the SKILL.md links into during Phases 4–6. No code; these are the judgment rubrics that keep AI output consistent.
|
||
|
||
- [ ] **Step 1: Write the stack recommendation guide**
|
||
|
||
Create `plugins/clone-app/skills/clone-app/references/stack-recommendation-guide.md`:
|
||
```markdown
|
||
# Stack Recommendation Guide (Phase 4)
|
||
|
||
Goal: present the user 2-3 concrete stack options for building the clone, then
|
||
let them pick. The pick locks effort + cost math in Phase 5.
|
||
|
||
## Inputs you have
|
||
- Detected original framework (from RE fingerprint): Native Kotlin/Java, Flutter, React Native, etc.
|
||
- Detected HTTP stack + backend signals (Retrofit/Ktor/Apollo/GraphQL/WebSocket).
|
||
- Feature surface (screen count, SDKs, permissions).
|
||
|
||
## How to choose the 2-3 options
|
||
Always include:
|
||
1. **Fastest for AI-assisted dev** — default to **Flutter** (single codebase, strong AI codegen, fast UI) unless the app is heavily native-platform-dependent.
|
||
2. **JS-ecosystem option** — **React Native + Expo** when the team is JS-leaning or web reuse matters.
|
||
3. **Match-the-original** — only when the original's nativeness is essential (deep platform APIs, AR, heavy native SDKs). Note the higher effort.
|
||
|
||
## Backend
|
||
- If RE shows first-party API hosts → a backend is required. Recommend **Node/TS (NestJS or Express)** or **Supabase** (fastest with AI) unless GraphQL detected → recommend **Apollo Server** or **Hasura**.
|
||
- If only third-party hosts (Firebase, payment SDKs) → likely **BaaS / no custom backend**; note it.
|
||
|
||
## Output format to the user
|
||
Present a short table: Option | Mobile stack | Backend | Why | Relative effort (Low/Med/High).
|
||
Then ask: "Which stack should I base the effort + cost estimate on?"
|
||
```
|
||
|
||
- [ ] **Step 2: Write the effort estimation guide**
|
||
|
||
Create `plugins/clone-app/skills/clone-app/references/effort-estimation-guide.md`:
|
||
```markdown
|
||
# Effort Estimation Guide (Phase 5) — AI-Assisted Units
|
||
|
||
Estimate in **AI Sprints**, NOT human days. 1 AI Sprint = one focused Claude
|
||
Code session producing a reviewable increment (~2-4h human review time).
|
||
|
||
## Method
|
||
1. Build the feature list from RE output:
|
||
- Screens = Activity + Fragment count (dedupe obvious base classes).
|
||
- API surface = endpoint count from find-api-calls.
|
||
- Integrations = third-party SDKs (auth, payment, maps, analytics, push, chat).
|
||
- Backend = REST/GraphQL/WebSocket presence + first-party host count.
|
||
2. Assign each feature a complexity and sprint range using the table below.
|
||
3. Sum to a range (min–max sprints). Never give a single false-precise number.
|
||
|
||
## Reference sprint costs
|
||
| Feature class | Low | Typical | High | Notes |
|
||
|---|---|---|---|---|
|
||
| Project scaffold + CI | 0.5 | 1 | 1 | nav, theming, state mgmt setup |
|
||
| Auth (email/social) | 1 | 1.5 | 2 | +1 if custom backend auth |
|
||
| Simple list/detail screen | 0.3 | 0.5 | 1 | per screen, AI-fast |
|
||
| Complex interactive screen | 1 | 2 | 3 | maps, editors, realtime |
|
||
| API integration layer | 1 | 2 | 3 | scales with endpoint count |
|
||
| Each major SDK integration | 0.5 | 1 | 2 | payment > maps > analytics |
|
||
| Custom backend (CRUD) | 2 | 4 | 8 | scales with entity + endpoint count |
|
||
| Realtime (WebSocket/push) | 1 | 2 | 4 | |
|
||
| Offline/sync | 2 | 3 | 5 | |
|
||
| Polish/QA/store submission | 1 | 2 | 3 | |
|
||
|
||
## Obfuscation caveat
|
||
If RE flagged heavy R8/Flutter (feature list incomplete), add a **+20-40%
|
||
uncertainty band** and state it explicitly in the report.
|
||
|
||
## Output
|
||
A table: Category | Complexity | Sprints (min–max), then a TOTAL row.
|
||
```
|
||
|
||
- [ ] **Step 3: Write the infra cost guide**
|
||
|
||
Create `plugins/clone-app/skills/clone-app/references/infra-cost-guide.md`:
|
||
```markdown
|
||
# Infrastructure Cost Guide (Phase 5)
|
||
|
||
Estimate **monthly USD** at three scales: MVP (<1k MAU), Growth (~50k MAU),
|
||
Scale (~500k MAU). Use round heuristics; mark assumptions.
|
||
|
||
## Components
|
||
| Component | MVP | Growth | Scale | Notes |
|
||
|---|---|---|---|---|
|
||
| App hosting/backend | $0-20 | $50-200 | $500-2k | Railway/Render/Fly → AWS/GCP |
|
||
| Managed DB (Postgres) | $0-15 | $50-150 | $300-1k | Supabase/Neon/RDS |
|
||
| Object storage/CDN | $0-5 | $20-80 | $200-800 | S3+CloudFront/Cloudflare |
|
||
| Auth (managed) | $0 | $0-100 | $200-500 | Supabase/Auth0 tiers |
|
||
| Push notifications | $0 | $0-50 | $50-300 | FCM free; OneSignal paid tiers |
|
||
| Third-party APIs | varies | varies | varies | maps, SMS, payments % |
|
||
| Monitoring | $0 | $20-50 | $100-300 | Sentry/Datadog |
|
||
|
||
## Third-party cost flags from RE
|
||
- Maps SDK → Google Maps billing after free tier.
|
||
- Payment SDK → % per transaction (Stripe ~2.9%+30¢).
|
||
- SMS/OTP → per-message (Twilio).
|
||
List each detected paid dependency explicitly.
|
||
|
||
## Output
|
||
A 3-column (MVP/Growth/Scale) monthly cost table + a one-line "biggest cost driver".
|
||
```
|
||
|
||
- [ ] **Step 4: Write the report template**
|
||
|
||
Create `plugins/clone-app/skills/clone-app/references/report-template.md`:
|
||
```markdown
|
||
# Clone Feasibility Report — {APP_TITLE}
|
||
|
||
**Package:** {PACKAGE}
|
||
**Date:** {DATE}
|
||
**Analyzed by:** clone-app skill
|
||
|
||
## 1. App Overview
|
||
- Title / developer / category / installs / rating ({RATING} from {RATING_COUNT} reviews)
|
||
- iOS App Store presence: {YES/NO + link}
|
||
- One-paragraph description of what the app does.
|
||
|
||
## 2. Tech Stack (Detected)
|
||
- Mobile framework: {framework} (RE fingerprint marker: {marker})
|
||
- HTTP stack: {Retrofit/Ktor/...}
|
||
- Backend signals: {first-party hosts, REST/GraphQL/WS}
|
||
- Notable SDKs: {list}
|
||
- Obfuscation level: {low/med/high} — analysis completeness caveat if high.
|
||
|
||
## 3. Recommended Clone Stack
|
||
- Selected by user: {stack}
|
||
- Rationale: {1-2 lines}
|
||
|
||
## 4. Feature List (from APK)
|
||
- Screens: {n}
|
||
- API endpoints: {n} (key ones listed)
|
||
- Integrations: {list}
|
||
- Backend required: {yes/no + why}
|
||
|
||
## 5. Effort Estimate (AI-Assisted)
|
||
{effort table from effort-estimation-guide}
|
||
**Total: {min}–{max} AI Sprints** (1 sprint ≈ one focused Claude Code session).
|
||
Uncertainty band: {±%} due to {reason}.
|
||
|
||
## 6. Infrastructure Cost Estimate (monthly)
|
||
{MVP/Growth/Scale table from infra-cost-guide}
|
||
Biggest cost driver: {item}.
|
||
|
||
## 7. Market Analysis
|
||
- Current app metrics: installs {x}, rating {y}, review velocity {if known}.
|
||
- Competitor landscape: {2-4 named competitors}.
|
||
- Target market size: {rough estimate + basis}.
|
||
- Differentiation opportunities: {list}.
|
||
|
||
## 8. Viability Verdict
|
||
**{GO / CONDITIONAL GO / NO GO}**
|
||
- Key risks: {list}
|
||
- Key opportunities: {list}
|
||
- Recommendation rationale: {2-3 sentences tying effort+cost vs market}.
|
||
|
||
## 9. Next Step
|
||
{Link to implementation plan if user proceeds, else "report only".}
|
||
```
|
||
|
||
- [ ] **Step 5: Commit**
|
||
|
||
```bash
|
||
cd /Users/fatih.bulut/PythonWorks/clone_app_skill && \
|
||
git add plugins/clone-app/skills/clone-app/references/ && \
|
||
git commit -m "docs(clone-app): add stack/effort/infra/report reference guides"
|
||
```
|
||
|
||
---
|
||
|
||
## Task 9: Orchestrator SKILL.md — all 8 phases
|
||
|
||
**Files:**
|
||
- Create: `plugins/clone-app/skills/clone-app/SKILL.md`
|
||
|
||
**Interfaces:**
|
||
- Consumes: all helper scripts (Tasks 2-6), the RE script dir (Task 3 resolver), and reference docs (Task 8). Uses `${CLAUDE_PLUGIN_ROOT}` for its own scripts.
|
||
- Produces: the activatable skill that runs the full Phase 0-7 workflow. Trigger phrases + frontmatter so Claude Code auto-loads it.
|
||
|
||
- [ ] **Step 1: Write SKILL.md**
|
||
|
||
Create `plugins/clone-app/skills/clone-app/SKILL.md`:
|
||
```markdown
|
||
---
|
||
description: Analyze a Google Play app to assess cloning it — download the APK, reverse engineer the tech stack and APIs, analyze app-store presence, estimate AI-assisted build effort and infrastructure cost, judge market viability, and optionally generate an implementation plan. Use when the user gives a Google Play URL or package name and wants a clone feasibility analysis, effort estimate, or tech-stack breakdown. 中文触发词：克隆应用、复刻这个app、分析可行性、估算开发量、克隆可行性分析
|
||
trigger: clone app|clone this app|clone feasibility|feasibility analysis|estimate effort to build|reverse engineer and clone|analyze this play store app|can I clone|克隆应用|复刻|可行性分析
|
||
---
|
||
|
||
# Clone App — Feasibility & Effort Analysis
|
||
|
||
Take a Google Play URL (or package name), reverse engineer the app, analyze its
|
||
market, estimate AI-assisted clone effort and infrastructure cost, and produce a
|
||
viability report. If the user approves, hand off to the writing-plans skill to
|
||
generate a full implementation plan.
|
||
|
||
This skill orchestrates 8 phases. Deterministic steps are factored into helper
|
||
scripts under `${CLAUDE_PLUGIN_ROOT}/skills/clone-app/scripts/`. Reverse
|
||
engineering reuses the sibling `android-reverse-engineering` plugin's scripts.
|
||
|
||
## Legal note
|
||
Only analyze apps you are authorized to (your own, or for lawful interoperability
|
||
/ research). Surface this to the user if intent is unclear. Do not proceed for
|
||
clearly infringing intent.
|
||
|
||
## Phase 0: Input & Validation
|
||
|
||
Extract the package name:
|
||
```bash
|
||
PKG="$(bash ${CLAUDE_PLUGIN_ROOT}/skills/clone-app/scripts/extract-package.sh "<user-input>")"
|
||
```
|
||
If it exits non-zero, ask the user for the package name directly, then re-run.
|
||
|
||
Create the working dir: `WORK="./work/$PKG"` and `mkdir -p "$WORK"`.
|
||
|
||
## Phase 1: APK Download
|
||
|
||
```bash
|
||
APK="$(bash ${CLAUDE_PLUGIN_ROOT}/skills/clone-app/scripts/download-apk.sh "$PKG" "$WORK")"
|
||
```
|
||
The script retries 3× and prints the path (`app.apk` or `app.xapk`). If it exits
|
||
non-zero, tell the user the download failed and ask for a local APK/XAPK path;
|
||
set `APK` to that path.
|
||
|
||
## Phase 2: Reverse Engineering
|
||
|
||
Resolve the sibling RE scripts:
|
||
```bash
|
||
RE="$(bash ${CLAUDE_PLUGIN_ROOT}/skills/clone-app/scripts/resolve-re-scripts.sh)"
|
||
```
|
||
If it exits non-zero, show its error (RE plugin not installed) and stop.
|
||
|
||
Run, in order, reading each output before the next:
|
||
1. `bash "$RE/fingerprint.sh" "$APK"` — framework, HTTP stack, obfuscation, SDKs, native libs.
|
||
- **If framework is Flutter / React Native / Cordova / Xamarin:** tell the user Java
|
||
decompilation is limited; proceed but rely on manifest + strings + hardcoded URLs +
|
||
the fingerprint SDK list. Skip steps 3-5's deep API extraction expectations.
|
||
2. `bash "$RE/check-deps.sh"` — parse `INSTALL_REQUIRED:` / `INSTALL_OPTIONAL:` lines.
|
||
Install required deps with `bash "$RE/install-dep.sh" <dep>`; re-run check-deps until clean.
|
||
Ask the user before installing optional deps (vineflower, dex2jar).
|
||
3. `bash "$RE/decompile.sh" "$APK"` (add `--deobf` if fingerprint showed heavy obfuscation).
|
||
Output lands under the RE script's `output/` — note the `sources/` path it prints.
|
||
4. If the app is Kotlin: `bash "$RE/recover-kotlin-names.sh" <sources> "$WORK/output/names/"`.
|
||
5. `bash "$RE/find-api-calls.sh" <sources>` (full scan; add `--ktor`/`--apollo`/`--paths` as
|
||
the fingerprint suggests).
|
||
|
||
From these outputs assemble: framework, HTTP stack, **API endpoint list**,
|
||
first-party vs third-party hosts, AndroidManifest summary (permissions, components),
|
||
and a **feature list** (screen count, SDKs, backend signals). Keep this in context
|
||
for later phases.
|
||
|
||
## Phase 3: Store Analysis
|
||
|
||
```bash
|
||
python3 ${CLAUDE_PLUGIN_ROOT}/skills/clone-app/scripts/scrape-play-store.py "$PKG" > "$WORK/play.json"
|
||
```
|
||
Read `play.json` for rating, rating_count, installs, category, developer, updated.
|
||
Use the `title` to check iOS:
|
||
```bash
|
||
python3 ${CLAUDE_PLUGIN_ROOT}/skills/clone-app/scripts/check-appstore.py "<title>" > "$WORK/appstore.json"
|
||
```
|
||
If Play scrape returned mostly nulls (page layout changed), fall back to a web
|
||
search for the app's metrics and note the source. App Store absence is fine —
|
||
continue with Google Play data only.
|
||
|
||
## Phase 4: Stack Recommendation
|
||
|
||
Read `${CLAUDE_PLUGIN_ROOT}/skills/clone-app/references/stack-recommendation-guide.md`.
|
||
Using the RE results + store data, present 2-3 stack options as a table and ask
|
||
the user to choose. **Wait for the user's choice before Phase 5.** Lock it.
|
||
|
||
## Phase 5: Effort & Cost Estimation
|
||
|
||
Read `${CLAUDE_PLUGIN_ROOT}/skills/clone-app/references/effort-estimation-guide.md`
|
||
and `infra-cost-guide.md`. Build:
|
||
- the feature list → AI-Sprint effort table (min-max total, uncertainty band),
|
||
- the MVP/Growth/Scale monthly infra cost table.
|
||
Base both on the **user-selected stack** from Phase 4.
|
||
|
||
## Phase 6: Market Viability Report
|
||
|
||
Read `${CLAUDE_PLUGIN_ROOT}/skills/clone-app/references/report-template.md`.
|
||
Fill every section from the data gathered. For market analysis (competitors,
|
||
market size), use web search as needed. Produce a GO / CONDITIONAL GO / NO GO
|
||
verdict tying effort + cost against market opportunity.
|
||
|
||
Write the report:
|
||
```
|
||
$WORK/clone-report-<YYYY-MM-DD>.md
|
||
```
|
||
(Use the actual run date.) Show the user a concise summary + the verdict.
|
||
|
||
## Phase 7: Decision Gate
|
||
|
||
Ask: "Report saved to `$WORK/clone-report-<date>.md`. Proceed to build the
|
||
implementation plan?"
|
||
- **Yes** → invoke the `superpowers:writing-plans` skill, passing the report as
|
||
context (the selected stack, feature list, and effort table become the plan's spec).
|
||
- **No** → stop; the report stands on its own.
|
||
|
||
## Error Handling Summary
|
||
| Scenario | Action |
|
||
|---|---|
|
||
| Package not in URL | ask user for package name |
|
||
| Download fails 3× | ask for local APK path |
|
||
| RE plugin missing | show resolver error, stop |
|
||
| Flutter/RN/Cordova/Xamarin | warn, continue with limited RE |
|
||
| App Store not found | continue Google Play only |
|
||
| Play scrape returns nulls | web-search fallback, note source |
|
||
| Heavy obfuscation | add uncertainty band, note in report |
|
||
| writing-plans unavailable | write the plan as Markdown manually |
|
||
```
|
||
|
||
- [ ] **Step 2: Validate frontmatter + links**
|
||
|
||
Run:
|
||
```bash
|
||
cd /Users/fatih.bulut/PythonWorks/clone_app_skill && \
|
||
python3 - <<'EOF'
|
||
import re, sys, os
|
||
p = "plugins/clone-app/skills/clone-app/SKILL.md"
|
||
s = open(p, encoding="utf-8").read()
|
||
assert s.startswith("---"), "missing frontmatter"
|
||
fm = s.split("---",2)[1]
|
||
assert "description:" in fm and "trigger:" in fm, "frontmatter keys missing"
|
||
# every referenced script/reference path under the plugin must exist
|
||
base = "plugins/clone-app/skills/clone-app"
|
||
for rel in ["scripts/extract-package.sh","scripts/download-apk.sh",
|
||
"scripts/resolve-re-scripts.sh","scripts/scrape-play-store.py",
|
||
"scripts/check-appstore.py","references/stack-recommendation-guide.md",
|
||
"references/effort-estimation-guide.md","references/infra-cost-guide.md",
|
||
"references/report-template.md"]:
|
||
assert os.path.isfile(os.path.join(base, rel)), f"missing {rel}"
|
||
print("OK")
|
||
EOF
|
||
```
|
||
Expected: `OK`
|
||
|
||
- [ ] **Step 3: Commit**
|
||
|
||
```bash
|
||
cd /Users/fatih.bulut/PythonWorks/clone_app_skill && \
|
||
git add plugins/clone-app/skills/clone-app/SKILL.md && \
|
||
git commit -m "feat(clone-app): add orchestrator SKILL.md (phases 0-7)"
|
||
```
|
||
|
||
---
|
||
|
||
## Task 10: `/clone-app` slash command + README
|
||
|
||
**Files:**
|
||
- Create: `plugins/clone-app/commands/clone-app.md`
|
||
- Create: `plugins/clone-app/README.md`
|
||
|
||
**Interfaces:**
|
||
- Consumes: SKILL.md (Task 9).
|
||
- Produces: the user-invocable `/clone-app <url>` command and install/usage docs.
|
||
|
||
- [ ] **Step 1: Write the command file**
|
||
|
||
Create `plugins/clone-app/commands/clone-app.md`:
|
||
```markdown
|
||
---
|
||
allowed-tools: Bash, Read, Glob, Grep, Write, Edit, WebFetch, WebSearch, Skill
|
||
description: Analyze a Google Play app for cloning — RE, effort, market viability, optional plan
|
||
user-invocable: true
|
||
argument-hint: <Google Play URL or package name>
|
||
argument: Google Play URL or package name (optional)
|
||
---
|
||
|
||
# /clone-app
|
||
|
||
Run the full clone-feasibility workflow on a Google Play app.
|
||
|
||
## Instructions
|
||
|
||
Follow the clone-app skill workflow in
|
||
`${CLAUDE_PLUGIN_ROOT}/skills/clone-app/SKILL.md` exactly, phases 0 through 7.
|
||
|
||
### Step 1: Get the target
|
||
If the user passed a URL or package name as an argument, use it. Otherwise ask
|
||
for the Google Play URL or package name.
|
||
|
||
### Step 2: Run the skill
|
||
Execute Phase 0 → Phase 7 from SKILL.md. Pause for the user at:
|
||
- Phase 4 (stack choice),
|
||
- Phase 7 (proceed to implementation plan?).
|
||
|
||
Honor the Error Handling Summary table in SKILL.md at every phase.
|
||
|
||
### Step 3: Deliver
|
||
Ensure the report is written to `./work/<package>/clone-report-<date>.md` and
|
||
summarize the verdict. If the user approves at Phase 7, invoke
|
||
`superpowers:writing-plans` with the report as the spec.
|
||
```
|
||
|
||
- [ ] **Step 2: Write the README**
|
||
|
||
Create `plugins/clone-app/README.md`:
|
||
```markdown
|
||
# clone-app — Clone Feasibility Analyzer (Claude Code skill)
|
||
|
||
Give it a Google Play URL. It downloads the APK, reverse engineers the tech
|
||
stack and APIs (via the sibling `android-reverse-engineering` plugin), analyzes
|
||
the app's store presence, estimates **AI-assisted** build effort (in AI Sprints)
|
||
and monthly infrastructure cost, judges market viability (GO / CONDITIONAL GO /
|
||
NO GO), and — if you approve — generates a full implementation plan.
|
||
|
||
## Requirements
|
||
- The `android-reverse-engineering` plugin (ships in this same repo).
|
||
- Java JDK 17+ and jadx (the RE plugin auto-installs jadx if missing).
|
||
- `curl`, Python 3 (stdlib only), `unzip`.
|
||
|
||
## Install
|
||
```text
|
||
/plugin marketplace add /path/to/this/repo
|
||
/plugin install android-reverse-engineering@android-reverse-engineering-skill
|
||
/plugin install clone-app@android-reverse-engineering-skill
|
||
```
|
||
|
||
## Usage
|
||
```text
|
||
/clone-app https://play.google.com/store/apps/details?id=com.example.app
|
||
```
|
||
Or natural language: "Analyze this Play Store app for cloning: <url>".
|
||
|
||
The skill pauses twice for your input: choosing the clone stack, and deciding
|
||
whether to generate the implementation plan.
|
||
|
||
## Output
|
||
```
|
||
./work/<package>/
|
||
├── app.apk | app.xapk
|
||
├── output/ # decompiled sources + Kotlin name maps
|
||
├── play.json # store metrics
|
||
├── appstore.json # iOS presence
|
||
└── clone-report-YYYY-MM-DD.md
|
||
```
|
||
|
||
## Keeping the RE plugin up to date
|
||
This repo is a fork. To pull upstream improvements:
|
||
```bash
|
||
git remote add upstream https://github.com/SimoneAvogadro/android-reverse-engineering-skill.git
|
||
git pull upstream master
|
||
```
|
||
The clone-app plugin lives in its own directory, so upstream updates to
|
||
`android-reverse-engineering` merge cleanly.
|
||
|
||
## Legal
|
||
For lawful use only — your own apps, authorized interoperability, security
|
||
research, or education. You are responsible for compliance.
|
||
```
|
||
|
||
- [ ] **Step 3: Validate command frontmatter**
|
||
|
||
Run:
|
||
```bash
|
||
cd /Users/fatih.bulut/PythonWorks/clone_app_skill && \
|
||
python3 -c "
|
||
s=open('plugins/clone-app/commands/clone-app.md',encoding='utf-8').read()
|
||
assert s.startswith('---') and 'user-invocable: true' in s and 'allowed-tools:' in s
|
||
print('OK')"
|
||
```
|
||
Expected: `OK`
|
||
|
||
- [ ] **Step 4: Commit**
|
||
|
||
```bash
|
||
cd /Users/fatih.bulut/PythonWorks/clone_app_skill && \
|
||
git add plugins/clone-app/commands/clone-app.md plugins/clone-app/README.md && \
|
||
git commit -m "feat(clone-app): add /clone-app command and README"
|
||
```
|
||
|
||
---
|
||
|
||
## Task 11: End-to-end smoke test + final verification
|
||
|
||
**Files:**
|
||
- Create: `plugins/clone-app/tests/smoke-structure.sh`
|
||
|
||
**Interfaces:**
|
||
- Produces: a structural smoke test verifying the whole plugin is wired correctly (all files present, all scripts executable, JSON valid, full test suite green). No network — this validates the package, not a live download.
|
||
|
||
- [ ] **Step 1: Write the smoke test**
|
||
|
||
Create `plugins/clone-app/tests/smoke-structure.sh`:
|
||
```bash
|
||
#!/usr/bin/env bash
|
||
set -uo pipefail
|
||
ROOT="$(cd "$(dirname "$0")/../../.." && pwd)" # repo root
|
||
P="$ROOT/plugins/clone-app"
|
||
fail=0
|
||
must_exist() { [[ -e "$1" ]] && echo "PASS exists: ${1#$ROOT/}" || { echo "FAIL missing: ${1#$ROOT/}"; fail=1; }; }
|
||
must_exec() { [[ -x "$1" ]] && echo "PASS exec: ${1#$ROOT/}" || { echo "FAIL not exec: ${1#$ROOT/}"; fail=1; }; }
|
||
|
||
must_exist "$P/.claude-plugin/plugin.json"
|
||
must_exist "$P/skills/clone-app/SKILL.md"
|
||
must_exist "$P/commands/clone-app.md"
|
||
must_exist "$P/README.md"
|
||
for s in extract-package.sh download-apk.sh resolve-re-scripts.sh; do
|
||
must_exist "$P/skills/clone-app/scripts/$s"; must_exec "$P/skills/clone-app/scripts/$s"
|
||
done
|
||
for s in scrape-play-store.py check-appstore.py; do
|
||
must_exist "$P/skills/clone-app/scripts/$s"
|
||
done
|
||
for r in stack-recommendation-guide effort-estimation-guide infra-cost-guide report-template; do
|
||
must_exist "$P/skills/clone-app/references/$r.md"
|
||
done
|
||
|
||
# JSON validity
|
||
python3 -c "import json;json.load(open('$P/.claude-plugin/plugin.json'));json.load(open('$ROOT/.claude-plugin/marketplace.json'))" \
|
||
&& echo "PASS json valid" || { echo "FAIL json invalid"; fail=1; }
|
||
|
||
# clone-app present in marketplace
|
||
python3 -c "
|
||
import json;d=json.load(open('$ROOT/.claude-plugin/marketplace.json'))
|
||
names=[p['name'] for p in d['plugins']]
|
||
assert 'clone-app' in names and 'android-reverse-engineering' in names
|
||
print('PASS marketplace has both plugins')" || { echo "FAIL marketplace entries"; fail=1; }
|
||
|
||
exit $fail
|
||
```
|
||
|
||
- [ ] **Step 2: Run smoke + full suite**
|
||
|
||
Run:
|
||
```bash
|
||
chmod +x /Users/fatih.bulut/PythonWorks/clone_app_skill/plugins/clone-app/tests/smoke-structure.sh && \
|
||
bash /Users/fatih.bulut/PythonWorks/clone_app_skill/plugins/clone-app/tests/smoke-structure.sh && \
|
||
bash /Users/fatih.bulut/PythonWorks/clone_app_skill/plugins/clone-app/tests/run-all.sh
|
||
```
|
||
Expected: smoke test all `PASS`; `ALL TESTS PASSED`. Both exit 0.
|
||
|
||
- [ ] **Step 3: Verify upstream plugin untouched**
|
||
|
||
Run:
|
||
```bash
|
||
cd /Users/fatih.bulut/PythonWorks/clone_app_skill && \
|
||
git status --porcelain plugins/android-reverse-engineering/ && \
|
||
echo "---" && \
|
||
git log --oneline -1
|
||
```
|
||
Expected: the `git status` line for `plugins/android-reverse-engineering/` is **empty** (no modifications to upstream). The `---` separator prints, then the last commit shows.
|
||
|
||
- [ ] **Step 4: Commit**
|
||
|
||
```bash
|
||
cd /Users/fatih.bulut/PythonWorks/clone_app_skill && \
|
||
git add plugins/clone-app/tests/smoke-structure.sh && \
|
||
git commit -m "test(clone-app): add structural smoke test"
|
||
```
|
||
|
||
- [ ] **Step 5: Final manual checklist (report to user, do not automate)**
|
||
|
||
Confirm and report:
|
||
- [ ] `git pull upstream master` strategy documented in README (Task 10) ✓
|
||
- [ ] Upstream `plugins/android-reverse-engineering/` has zero diffs (Step 3) ✓
|
||
- [ ] All scripts tested green (Step 2) ✓
|
||
- [ ] Skill triggers + command are wired (Tasks 9-10) ✓
|
||
- [ ] Recommend the user do ONE live run against a known small app to validate the
|
||
network paths (APKPure download + Play scrape), since those aren't covered by
|
||
offline tests. Suggest: pick a small free app, run `/clone-app <url>`, stop
|
||
after Phase 3 to confirm download + store JSON look right.
|
||
|
||
---
|
||
|
||
## Self-Review Notes
|
||
|
||
**Spec coverage check:**
|
||
- Phase 0-7 → Task 9 SKILL.md ✓ (all phases present, in order)
|
||
- Repo structure / upstream-untouched → Task 1 + Task 11 Step 3 verification ✓
|
||
- APK download w/ retries + xapk detect → Task 4 ✓
|
||
- RE script invocation via sibling path → Task 3 resolver + Task 9 Phase 2 ✓
|
||
- Store analysis (Play + App Store) → Tasks 5, 6 + Phase 3 ✓
|
||
- Stack recommendation (Option C + user choice) → Task 8 guide + Phase 4 ✓
|
||
- Effort estimation in AI Sprints → Task 8 guide + Phase 5 ✓
|
||
- Infra cost → Task 8 guide + Phase 5 ✓
|
||
- Market viability report + GO/NO-GO → Task 8 template + Phase 6 ✓
|
||
- Decision gate → writing-plans handoff → Phase 7 ✓
|
||
- All error-handling rows → Phase 2/3 + SKILL.md error table ✓
|
||
- Known limitations (iOS, obfuscation, install ranges) → reflected in guides/template ✓
|
||
- Install instructions → Task 10 README ✓
|
||
|
||
**Placeholder scan:** No TBD/TODO; all code blocks complete; report-template uses
|
||
intentional `{PLACEHOLDER}` tokens that are fill-in fields for runtime, not plan gaps.
|
||
|
||
**Type/name consistency:** Script names, JSON keys (`package/title/rating/rating_count/
|
||
installs/category/developer/updated/source`; `found/source/results/name/seller/rating/
|
||
rating_count/price/url`), and env vars (`CLAUDE_PLUGIN_ROOT`, `CLONE_APP_CURL`) match
|
||
across tasks. `$WORK`, `$PKG`, `$APK`, `$RE` consistent in SKILL.md.
|
||
```
|