Remove example templates for various programming languages (Node.js, PHP, Python, Ruby, Rust) and mock API server. This includes deleting package files, solution scripts, and associated dependencies to streamline the project structure and focus on core functionality.

Author: bshahin

.github/workflows/ci.yml

@@ -231,7 +231,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - name: Check required files and ALL 10 language directories
+      - name: Check required files and at least one supported implementation
         run: |
           errors=0
           ALL_LANGS="python node php go java csharp ruby rust kotlin bash"
@@ -248,19 +248,23 @@ jobs:
               errors=$((errors + 1))
             fi
 
-            # ALL 10 language directories required
+            # At least one supported language directory required
+            lang_count=0
             for lang in $ALL_LANGS; do
-              if [ ! -d "$dir/$lang" ]; then
-                echo "ERROR: $dir is missing $lang/ directory"
-                errors=$((errors + 1))
+              if [ -d "$dir/$lang" ]; then
+                lang_count=$((lang_count + 1))
               fi
             done
+            if [ $lang_count -eq 0 ]; then
+              echo "ERROR: $dir does not contain a supported language directory"
+              errors=$((errors + 1))
+            fi
           done
           if [ $errors -gt 0 ]; then
             echo "Found $errors structural errors"
             exit 1
           fi
-          echo "All example packs have complete structure (10 languages)"
+          echo "All example packs have required files and at least one supported implementation"
 
       - name: Check no .env files committed
         run: |

.gitignore

@@ -7,6 +7,3 @@ composer.lock
 package-lock.json
 .DS_Store
 Thumbs.db
-
-# Internal planning directory (excluded from git)
-.planning/

CONTRIBUTING.md

@@ -1,308 +1,44 @@
-# Contributing to CaptchaAI Examples
+# Working With CaptchaAI Examples
 
-## Overview
+This repository is maintained internally and published so CaptchaAI clients can get to working example code quickly.
 
-This repository holds full working code examples that accompany [CaptchaAI blog articles](https://blog.captchaai.com). Each example is a complete, runnable project — not a snippet.
+The public contract here is simple: each pack under `articles/{slug}/` is a client-facing example, and the README inside that pack is the setup and usage guide clients should follow.
 
-## Support tiers
+## Public vs private
 
-Every example pack is classified into a support tier:
+- Public: blog articles on `blog.captchaai.com` and the example packs in this repository.
+- Private: the editorial workflow, generation pipeline, maintenance scripts, and internal review process used to create and update those outputs.
 
-| Tier | Badge | Criteria |
-|------|-------|----------|
-| **Verified** | 🟢 | All 10 languages CI-linted, solver-correct, manually reviewed |
-| **Standard** | 🟡 | All 10 languages present, scaffolded from verified templates, basic validation passes |
-| **Generated** | ⚪ | Scaffolded from template, may have known issues pending review |
+This public repo intentionally contains the published packs only. Internal templates, tools, scaffolding, repair scripts, smoke tooling, and other maintenance automation stay in the private factory.
 
-### Promotion path
+This repo exists to serve clients, not to document the internal factory that produces content and examples.
 
-```
-Generated → Standard → Verified
-```
+## Support levels
 
-**Generated → Standard:** Fix any null labels, fix mojibake, ensure blog backlink, pass CI.
+We use support levels to describe the current confidence level honestly, not to imply perfection across every included language.
 
-**Standard → Verified:** All 10 languages CI-linted, solver correctness validated (method + response field + params), manual code review completed.
+| Tier | Badge | What it means |
+|------|-------|---------------|
+| **Verified** | 🟢 | The pack's reference flow has been reviewed closely and checked against current CaptchaAI behavior and repo validation. This is the highest-confidence level in the public repo, but not every included language always receives identical review depth. |
+| **Standard** | 🟡 | The pack is documented, available, and structurally checked. At least one implementation has been reviewed, while other included implementations may still be receiving lighter validation or iterative improvement. |
+| **Available** | ⚪ | The pack is published because it is useful to clients, with lighter review depth than Standard or Verified. It is available for reference without claiming perfect parity across every included implementation. |
 
-### CI-validated languages
+## Language coverage
 
-The following languages are checked in CI:
+Many packs currently include Python, Node.js, PHP, Go, Java, C#, Ruby, Rust, Kotlin, and Bash.
 
-| Language | CI Check | Status |
-|----------|----------|--------|
-| Python | `ruff` (syntax + style) | Enforced |
-| Node.js | `acorn` (ECMAScript 2020) | Enforced |
-| PHP | `php -l` (syntax) | Enforced |
-| Go | `go vet` / `gofmt` | Enforced |
-| Ruby | `ruby -c` (syntax) | Enforced |
-| Bash | `bash -n` + `shellcheck` | Enforced |
-| Java | `javac` (compilation) | Enforced |
-| Kotlin | `kotlinc` (syntax) | Best-effort |
-| C# | — | Planned |
-| Rust | — | Planned |
+That is a current coverage choice, not a permanent promise for every pack now or later. The README and support tier of a specific pack are the source of truth for what level of support you should expect.
 
-## When to add an example
+## What we check publicly
 
-An example pack should be created when:
+The public quality bar focuses on usefulness and honesty:
 
-- The blog article type is: API tutorial, Tutorial, Integration guide, Framework, DevOps tutorial, Project tutorial, or Use case guide
-- The example provides clear value beyond the in-article code snippets
-- The article has a complete draft (not a placeholder)
-- The article's `editorial_review` is not `manual-only`
+- Correct CaptchaAI API endpoints and parameter usage
+- Clear setup instructions and environment configuration
+- A working blog backlink for context
+- Lint or compile checks where toolchains are available
+- Deeper runtime or smoke validation on selected reference flows
 
-Do **not** create an example pack when:
+## External contributions
 
-- The in-article snippet is sufficient on its own
-- The article is a comparison, explainer, or reference with no meaningful runnable code
-- The example would be shallow or trivial (single API call with no workflow)
-
-## Structure
-
-Every example pack lives under `articles/{slug}/` and must contain:
-
-```
-articles/{slug}/
-  README.md          # Setup, usage, expected output, troubleshooting
-  .env.example       # All required environment variables with descriptive comments
-  .gitignore         # Excludes .env, build artifacts for all languages
-  python/            # Python implementation
-    solve.py
-    requirements.txt
-  node/              # Node.js implementation
-    solve.js
-    package.json
-  php/               # PHP implementation
-    solve.php
-    composer.json
-  go/                # Go implementation
-    solve.go
-    go.mod
-  java/              # Java implementation
-    Solve.java
-  csharp/            # C# implementation
-    Solve.cs
-    Solve.csproj
-  ruby/              # Ruby implementation
-    solve.rb
-    Gemfile
-  rust/              # Rust implementation
-    src/main.rs
-    Cargo.toml
-  kotlin/            # Kotlin implementation
-    solve.kt
-  bash/              # Bash/cURL implementation
-    solve.sh
-```
-
-## Supported languages
-
-Every example pack **must** include all 10 supported languages:
-
-| Language | Directory | Entry point | Manifest |
-|----------|-----------|-------------|----------|
-| Python | `python/` | `solve.py` | `requirements.txt` |
-| Node.js | `node/` | `solve.js` | `package.json` |
-| PHP | `php/` | `solve.php` | `composer.json` |
-| Go | `go/` | `solve.go` | `go.mod` |
-| Java | `java/` | `Solve.java` | — |
-| C# | `csharp/` | `Solve.cs` | `Solve.csproj` |
-| Ruby | `ruby/` | `solve.rb` | `Gemfile` |
-| Rust | `rust/` | `src/main.rs` | `Cargo.toml` |
-| Kotlin | `kotlin/` | `solve.kt` | — |
-| Bash/cURL | `bash/` | `solve.sh` | — |
-
-## Code requirements
-
-### API endpoints
-
-- Submit: `https://ocr.captchaai.com/in.php`
-- Poll: `https://ocr.captchaai.com/res.php`
-- Always use `json=1` for structured responses
-- Never hardcode alternative or mock endpoints
-
-### Credentials
-
-- Load from `.env` file (dotenv for languages that support it, manual parsing for others)
-- Use `YOUR_API_KEY` as the placeholder in `.env.example`
-- Use `YOUR_SITE_KEY` as the placeholder for sitekeys
-- Never commit real API keys
-- `.gitignore` must exclude `.env`
-
-### Input validation
-
-Every example must validate before making any API call:
-
-- API key is set and not a placeholder
-- Sitekey is set and not a placeholder
-- Page URL is set and not the default example value
-- Exit immediately with a clear message on missing config
-
-### Polling
-
-- Wait 15-20 seconds before first poll
-- Poll every 5 seconds (configurable via `POLL_INTERVAL`)
-- Handle `CAPCHA_NOT_READY` as normal in-progress
-- Implement a maximum timeout (default: 120 seconds, configurable via `MAX_TIMEOUT`)
-- Log each poll attempt with attempt number
-
-### Error handling
-
-Handle **all** documented error categories:
-
-| Category | Errors | Handling |
-|----------|--------|----------|
-| Auth | `ERROR_WRONG_USER_KEY`, `ERROR_KEY_DOES_NOT_EXIST`, `IP_BANNED` | Exit with clear message about API key |
-| Balance | `ERROR_ZERO_BALANCE` | Exit with message to top up account |
-| Input | `ERROR_PAGEURL`, `ERROR_WRONG_GOOGLEKEY`, `ERROR_BAD_PARAMETERS`, `ERROR_BAD_TOKEN_OR_PAGEURL` | Exit with parameter validation message |
-| Transient | `ERROR_SERVER_ERROR`, `ERROR_INTERNAL_SERVER_ERROR` | Retry with exponential backoff (cap at 30s) |
-| Solve | `ERROR_CAPTCHA_UNSOLVABLE` | Exit with message to verify parameters |
-| Proxy | `ERROR_BAD_PROXY`, `ERROR_PROXY_CONNECTION_FAILED` | Exit with message to check proxy config |
-
-### Token injection guidance
-
-The final output message must reference the **correct** response field for the CAPTCHA type:
-
-| CAPTCHA Type | Response field |
-|-------------|---------------|
-| reCAPTCHA v2/v3 | `g-recaptcha-response` |
-| Cloudflare Turnstile | `cf-turnstile-response` |
-| GeeTest | Custom callback |
-| hCaptcha | `h-captcha-response` |
-| Image CAPTCHA | Direct text value |
-
-**Never** use `g-recaptcha-response` for non-reCAPTCHA types. This is a hard rule.
-
-### Output format
-
-All languages must produce identical output format:
-
-```
-[*] Submitting {CAPTCHA_TYPE} task...
-[+] Task submitted. ID: {id}
-[*] Waiting 15s before first poll...
-[*] Polling for result (attempt {n})...
-[*] Not ready yet, waiting {n}s...
-[+] Solved! Token: {first_50_chars}...
-[+] Full token length: {n} characters
-
-Next step: inject this token into the target page's
-{correct_response_field} hidden field and submit the form.
-```
-
-### Expected output
-
-Include a section in the README showing what a successful run looks like.
-
-### Code style
-
-- Python: PEP 8
-- Node.js: StandardJS or Prettier defaults
-- PHP: PSR-12
-- Go: gofmt
-- Java: Google Java Style
-- C#: .NET conventions
-- Ruby: Standard Ruby style
-- Rust: rustfmt
-- Kotlin: Kotlin Coding Conventions
-- Bash: ShellCheck-clean
-
-## README template
-
-Every example README must include:
-
-1. Title (matches the article)
-2. Description (includes CAPTCHA type)
-3. Languages list
-4. Link to the blog article
-5. Prerequisites (with version requirements)
-6. Setup instructions (clone → install → configure → run) for **every** language
-7. Environment variables table with descriptions
-8. How it works (4-step flow)
-9. Expected output (full console output)
-10. Common errors table (error → cause → fix)
-11. Troubleshooting (at least 3 scenarios)
-12. API docs link
-13. Related examples
-
-## Linking
-
-- Example README links to: blog article, API docs, related examples
-- Blog article links to: example repo path using a **clickable anchor**, not a raw URL
-
-Correct article CTA format:
-
-```md
-## Full runnable example
-
-Need a complete working project with environment setup, polling, retries, and error handling?
-
-[See the full runnable example on GitHub →](https://github.com/CaptchaAI/CaptchaAI-Examples/tree/main/articles/{slug})
-```
-
-## Quality checklist — Code
-
-Before submitting, **every language** in the example pack must pass:
-
-### Correctness
-- [ ] Code uses real CaptchaAI API endpoints (`in.php` submit, `res.php` poll)
-- [ ] API method parameter matches the CAPTCHA type (e.g. `turnstile` not `userrecaptcha` for Turnstile)
-- [ ] Token injection message references the correct response field for the CAPTCHA type
-- [ ] Field names in code match the API documentation exactly
-- [ ] `.env.example` lists all required variables with descriptive comments
-
-### Consistency across languages
-- [ ] All languages use the same `.env` variable names
-- [ ] All languages use the same poll interval default (5s)
-- [ ] All languages use the same max timeout default (120s)
-- [ ] All languages use the same initial wait (15s)
-- [ ] All languages produce the same output format
-- [ ] All languages handle the same error categories
-- [ ] All languages validate config before making API calls
-
-### Error handling
-- [ ] Auth errors → clear message about API key
-- [ ] Balance errors → message to top up
-- [ ] Input errors → parameter validation message
-- [ ] Transient errors → retry with exponential backoff (cap at 30s)
-- [ ] Solve errors → exit with verify message
-- [ ] Proxy errors → exit with proxy check message
-- [ ] Network errors → caught and reported (not unhandled crashes)
-- [ ] Missing config → clear message before any API call
-
-### Security
-- [ ] No real API keys, tokens, or secrets in code
-- [ ] No hardcoded credentials
-- [ ] `.gitignore` excludes `.env` and all build artifacts
-- [ ] HTTP timeouts set on all requests (30s)
-- [ ] No eval() or equivalent dynamic code execution
-
-### Quality
-- [ ] Code follows the language's standard style guide
-- [ ] Setup instructions work from clone to first run
-- [ ] README links back to the blog article
-- [ ] Expected output in README matches actual output format
-- [ ] Dependencies are minimal (prefer stdlib where possible)
-
-## Quality checklist — README
-
-- [ ] Title matches the blog article title
-- [ ] Description mentions the specific CAPTCHA type
-- [ ] All supported languages are listed
-- [ ] Prerequisites include version requirements
-- [ ] Setup instructions cover every language
-- [ ] Environment variables table is complete
-- [ ] How it works matches the actual code flow
-- [ ] Expected output matches what the code actually prints
-- [ ] Common errors table covers all 6 error categories
-- [ ] Troubleshooting covers at least 3 failure scenarios
-- [ ] No references to wrong CAPTCHA types (e.g. reCAPTCHA wording in a Turnstile example)
-
-## Scaffolding
-
-New example packs are scaffolded using the tool in the `cai_content` repository:
-
-```bash
-python scripts/scaffold_example_pack.py articles/{slug}.md --examples-repo ../CaptchaAI-Examples
-```
-
-This generates the directory structure, README template, `.env.example`, and starter code files for all 10 languages.
+This repository is not running a broad external contribution workflow right now. If that changes, this file will be updated.