ei-agentic-claude 1.0.0

package/README.md

@@ -0,0 +1,360 @@
+
+# Edge Impulse Claude Code MCP Integration
+
+A Model Context Protocol (MCP) server that enables Claude Code to interact with Edge Impulse APIs. This project provides integration between Anthropic's Claude Code and Edge Impulse's machine learning platform.
+
+## Example of usage
+
+### CLI Usage
+<img width="1111" height="571" alt="Screenshot 2026-01-23 at 16 54 01" src="https://github.com/user-attachments/assets/3fd11801-2948-48ad-b71f-f5117eb9a7f7" />
+
+### Calling API on Block
+<img width="1111" height="76" alt="Screenshot 2026-01-23 at 17 13 32" src="https://github.com/user-attachments/assets/8821b5da-021f-4fd3-a27d-0ee020ab5960" />
+
+### Job Status
+<img width="1207" height="76" alt="Screenshot 2026-01-23 at 17 17 13" src="https://github.com/user-attachments/assets/3adb2bd6-da51-4c0e-8f16-a61765c32af1" />
+
+### Testing Framework
+<img width="1207" height="274" alt="Screenshot 2026-01-23 at 17 29 24" src="https://github.com/user-attachments/assets/fe91d73b-ec09-4b4d-a669-1286fe43382a" />
+
+## What can claude do?? Well it can configure your project from 99.6 to 100% accuracy on the first try!!
+
+Use it to configure your blocks and review your config, e.g.
+
+<img width="1802" height="326" alt="image" src="https://github.com/user-attachments/assets/4c57622d-44f3-43a7-a80a-b3c1bbe0cf17" />
+<img width="3984" height="2070" alt="image" src="https://github.com/user-attachments/assets/85622e5d-13f4-4d4a-a447-e048aef353ac" />
+<img width="3984" height="2070" alt="image" src="https://github.com/user-attachments/assets/098071bd-904f-4af2-ab34-72513066c659" />
+<img width="3984" height="2070" alt="image" src="https://github.com/user-attachments/assets/e9c80bdf-1215-4684-8e1a-bbbdcf31457e" />
+
+
+## BC
+<img width="1118" height="2080" alt="image" src="https://github.com/user-attachments/assets/9da7bf78-cd12-4fb9-968b-0136f21af2b2" />
+
+
+## AC
+<img width="1118" height="1942" alt="image" src="https://github.com/user-attachments/assets/135adfba-0814-4b9e-a8bf-16f785baab9b" />
+
+
+
+
+
+## Security
+
+### API Key Management
+- API keys are stored in a local `.env` file (not committed to git)
+- Keys are validated for presence and format before API calls
+- Use `cp .env.example .env` to create your secure configuration
+
+### Generated Code Integrity
+- Generated API client files include SHA256 integrity checks
+- Run `npm run generate-integrity` after generating new client files
+- Files are validated at runtime before loading
+- Integrity hashes stored in `integrity.json` alongside generated files
+- Verify the Postman collection source before generating clients
+
+### Dynamic Import Security
+- **Integrity Validation**: SHA256 hashes are computed and verified for all generated API client files
+- **Runtime Checks**: Files are validated before loading to prevent tampering
+- **Sandboxing**: Implemented for MCP server API calls using Node.js vm module with restricted context
+- Generated code runs in sandboxed environment with limited globals (fetch, JSON, timers only)
+- CLI commands run in main process (user-initiated, lower risk)
+
+### Rate Limiting
+- API calls are subject to Edge Impulse's rate limits
+- Consider implementing client-side rate limiting for high-volume usage
+- Monitor API usage in your Edge Impulse dashboard
+
+## Quick Start
+
+### 1. Install Claude Code
+```bash
+curl -fsSL https://claude.ai/install.sh | bash
+```
+
+### 2. Clone and Setup
+```bash
+git clone <repository-url>
+cd ei-agentic-claude
+npm install
+npm run build
+
+# Optional: Run the automated setup script (loads .env automatically)
+./setup-claude.sh
+```
+
+### 3. Configure Claude Code
+```bash
+# Add the Edge Impulse MCP server
+claude mcp add edge-impulse -- node dist/mcp-server.js
+
+# Verify connection
+claude mcp list
+```
+
+### 4. Configure API Keys
+**Secure Setup (Recommended):**
+```bash
+# Copy the example environment file
+cp .env.example .env
+
+# Edit .env with your actual API keys
+# ANTHROPIC_API_KEY=your_anthropic_api_key_here
+# EI_API_KEY=your_edge_impulse_api_key_here
+```
+
+**Quick Setup (for testing):**
+```bash
+export ANTHROPIC_API_KEY=your_claude_api_key
+export EI_API_KEY=your_edge_impulse_api_key
+```
+
+> **🔒 Security Note:** API keys are stored in `.env` files (not committed to git). See [API Key Management](#api-key-management) for detailed setup options.
+
+### 5. Start Using Claude Code
+```bash
+claude -p "Show me all my Edge Impulse projects"
+```
+
+## Table of Contents
+- [Quick Start](#quick-start)
+- [Security](#security)
+- [Automated Setup](#automated-setup)
+- [Screenshots](#screenshots)
+- [Claude Code Integration](#claude-code-integration)
+- [CLI Usage](#cli-usage)
+- [API Coverage](#api-coverage)
+- [Testing](#testing)
+- [Development](#development)
+
+## Automated Setup
+
+For convenience, you can use the included setup script to automate the Claude Code integration:
+
+```bash
+# Ensure you have .env configured first
+cp .env.example .env
+# Edit .env with your API keys
+
+# Run the setup script
+./setup-claude.sh
+```
+
+The script will:
+- Load API keys from your `.env` file
+- Test Claude Code authentication
+- Verify MCP server connectivity
+- Test Edge Impulse API access
+
+## Screenshots
+
+### CLI Usage
+<img width="1111" height="571" alt="Screenshot 2026-01-23 at 16 54 01" src="https://github.com/user-attachments/assets/3fd11801-2948-48ad-b71f-f5117eb9a7f7" />
+
+### Calling API on Block
+<img width="1111" height="76" alt="Screenshot 2026-01-23 at 17 13 32" src="https://github.com/user-attachments/assets/8821b5da-021f-4fd3-a27d-0ee020ab5960" />
+
+### Job Status
+<img width="1207" height="76" alt="Screenshot 2026-01-23 at 17 17 13" src="https://github.com/user-attachments/assets/3adb2bd6-da51-4c0e-8f16-a61765c32af1" />
+
+### Testing Framework
+<img width="1207" height="274" alt="Screenshot 2026-01-23 at 17 29 24" src="https://github.com/user-attachments/assets/fe91d73b-ec09-4b4d-a669-1286fe43382a" />
+
+## Tutorials
+
+- **Wheeled ROS2 Robot:** Basic setup and navigation in ROS2, building on wheeled robot demos. Covers URDF, sensor integration, and navigation stacks.
+- **Robotic Arm:** Introduction to arm control, kinematics, and basic movements. Includes trajectory planning and simple controllers.
+- **Simulated Robotic Arm (Gazebo):** Setting up arm simulation in Gazebo, integrating with the ROS2 stack and testing control loops.
+- **Simulated Arm with Manual Training & Imitation:** Record teleoperation demonstrations, train policies (imitation learning / RL), and reproduce on a second arm.
+- **Arm on Wheeled Robot:** Integrate arm manipulation with wheeled mobility to perform combined tasks (pick-and-place while moving).
+
+These tutorials map to example workflows for scene reconstruction, simulation, model profiling for NPUs, and ROS-based deployment pipelines. If you want, I can scaffold one tutorial with example URDF, launch files, and a Gazebo scene.
+
+
+# Development & Production Usage
+
+## Universal CLI Launcher (Recommended)
+Use the provided launcher script to automatically detect and run the CLI in the correct mode:
+
+```
+node launch-cli.mjs get-all-projects --api-key <your_api_key>
+```
+
+This script will:
+- Use `ts-node` and `.ts` sources if available (development mode)
+- Use compiled `.js` files from `dist` if running in production
+
+## Manual Usage
+
+### Development (TypeScript, ts-node)
+Run CLI commands directly with TypeScript using ts-node:
+
+```
+npm run cli -- get-all-projects --api-key <your_api_key>
+```
+
+### Production (after build)
+First, build the project:
+
+```
+npx tsc
+```
+Then run the compiled CLI from the `dist` directory:
+
+```
+node dist/cli.js get-all-projects --api-key <your_api_key>
+```
+
+# Storing Your API Key for Easier CLI Usage
+
+You can avoid typing your API key every time by using one of these methods:
+
+**1. Environment variable (recommended):**
+Add this to your shell profile (e.g., `~/.zshrc` or `~/.bashrc`):
+```sh
+export EI_API_KEY=ei_XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+```
+Then run commands like:
+```sh
+npm run cli -- get-all-projects --api-key $EI_API_KEY
+```
+
+**2. .env file with `dotenv-cli` (Most Secure):**
+Install dotenv-cli:
+```sh
+npm install -g dotenv-cli
+```
+Copy the example file and fill in your keys:
+```sh
+cp .env.example .env
+```
+Edit `.env` with your actual API keys:
+```
+ANTHROPIC_API_KEY=your_anthropic_api_key_here
+EI_API_KEY=your_edge_impulse_api_key_here
+```
+Run commands with:
+```sh
+dotenv -e .env -- npm run cli -- get-all-projects --api-key $EI_API_KEY
+```
+
+> **🔒 Security:** `.env` files are automatically ignored by git and never committed to version control.
+
+**3. Shell alias:**
+Add to your shell profile:
+```sh
+alias eicli='npm run cli -- --api-key $EI_API_KEY'
+```
+Then run:
+```sh
+eicli get-all-projects
+
+## New: `--params` JSON and optional `organizationId`
+
+Many generated commands accept a `--params` option which takes a JSON string of parameters. For project listing we made `organizationId` optional — if supplied the CLI will call the organization-scoped endpoint, otherwise it will call the user-facing projects endpoint.
+
+Examples:
+
+```sh
+# List projects for API key (no organization required)
+node launch-cli.mjs get-projects --api-key $EI_API_KEY --params '{"type":"classification"}'
+
+# List projects for an organization (organizationId is optional)
+node launch-cli.mjs get-projects --api-key $EI_API_KEY --params '{"organizationId":"1478","type":"classification"}'
+```
+
+The same `--params` JSON pattern is used by other commands — e.g., training commands accept `projectId`, `learnId`, and training parameters through `--params`.
+
+If you prefer top-level flags, many commands still accept specific flags generated in the CLI files (check `--help` for the command).
+```
+
+
+# Auto-Generated CLI Commands (Extensible Secondary Layer)
+
+All Edge Impulse API endpoints are available as CLI commands, auto-generated from the Postman collection. This auto-generation is designed as a secondary, extensible layer—making it easy to add, update, or extend commands as the API evolves.
+
+4. **(Optional) Fetch evaluation metrics:**
+You (or Claude) can configure any Keras block parameter at training time using the CLI's `--param` option. Example:
+```sh
+npm run cli -- start-training --api-key <your_api_key> --projectId <projectId> --learnId <learnId> \
+# Edge Impulse Claude Code MCP Integration
+
+MCP server and CLI for Edge Impulse APIs, with Docker image, prompt-generation tooling, and CI smoke tests. Claude (or other agents) can call the APIs via stdio MCP or the generated CLI.
+
+## Highlights
+- MCP server (stdio) and universal CLI launcher (`node launch-cli.mjs ...`).
+- Generated CLI commands for all Edge Impulse endpoints (`src/postman/edge-impulse/generated/cli-commands`).
+- Dockerized runtime with healthcheck and non-root user.
+- Tests: Vitest unit suite, Docker smoke, project connectivity, prompt/LLM simulation, apply-flow dry run.
+- Sample env files: `.env.example` and `.env.test.sample` (redacted) — actual secrets stay local.
+
+## Screenshots (orientation)
+- CLI help and commands: ![CLI usage](https://github.com/user-attachments/assets/3fd11801-2948-48ad-b71f-f5117eb9a7f7)
+- Invoke API block: ![Call block](https://github.com/user-attachments/assets/8821b5da-021f-4fd3-a27d-0ee020ab5960)
+- Job status output: ![Job status](https://github.com/user-attachments/assets/3adb2bd6-da51-4c0e-8f16-a61765c32af1)
+
+## Prerequisites
+- Node 20+
+- npm 9+
+- Docker (for container build/test)
+- Edge Impulse API key (set in `.env` or exported)
+
+## Setup
+```bash
+git clone https://github.com/edgeimpulse/ei-agentic-claude.git
+cd ei-agentic-claude
+npm install
+npm run build
+
+# create envs (keep private)
+cp .env.example .env
+cp .env.test.sample .env.test  # for local tests
+```
+
+## Running
+- **CLI (auto-detects ts vs dist)**
+  ```bash
+  node launch-cli.mjs get-all-projects --api-key $EI_API_KEY
+  node launch-cli.mjs wait-job --help
+  ```
+- **MCP server (stdio)**: `node dist/mcp-server.js`
+- **Claude hookup**: `claude mcp add edge-impulse -- node dist/mcp-server.js`
+
+## Docker
+- Build: `docker build -t ei-agentic-claude:latest .`
+- Run (stdio, env mounted):
+  ```bash
+  docker run --rm -it --name ei-mcp \
+    -v "$PWD/.env.test:/app/.env.test:ro" \
+    ei-agentic-claude:latest
+  ```
+- Smoke test: `npm run docker:test` (waits for readiness line `Edge Impulse MCP server running on stdio`).
+
+## Tests (no live LLM calls)
+- Unit: `npm test` (builds first via pretest).
+- Docker smoke: `npm run docker:test`.
+- Project connectivity (needs `.env.test` with EI_API_KEY and project IDs): `npm run project:test`.
+- Prompt generation + simulated LLM/apply flow: `npm run test:apply-flow` (writes prompts to /tmp, simulated responses + dry-run apply scripts to outputs/).
+
+## Prompt & apply tooling
+- Generate prompts per project/goal: `npm run prompt:test` (uses `/tmp/project-*.json` from project:test).
+- Simulate LLM responses and dry-run apply scripts: `npm run test:apply-flow`.
+- Optional real LLM: add `ANTHROPIC_API_KEY` to `.env.test` and use `npm run llm:run` (not part of CI).
+
+## Security & integrity
+- Secrets stay in `.env` / `.env.test` (git-ignored). Example placeholders only.
+- Generated client integrity hashes live in `src/postman/edge-impulse/integrity.json`; validate with `npm run generate-integrity` after regeneration.
+- Container runs as non-root; healthcheck ensures `dist/mcp-server.js` is alive.
+
+## Troubleshooting
+- CLI shows no commands: run `npm run build` (pretest does this), then `node launch-cli.mjs --help`.
+- Docker test hangs: check for readiness line; ensure `.env.test` is mounted if you need API keys.
+- Prompt tests return HTML: indicates auth/endpoint issue; runners fall back to placeholder JSON so prompts still generate.
+
+## CI
+GitHub Actions (`.github/workflows/ci.yml`) runs `npm ci`, `npm test`, and `npm run docker:test` on push/PR.
+
+## Development tips
+- Generated commands reside under `src/postman/edge-impulse/generated/cli-commands`; names map underscore → dash (e.g., `wait_job.ts` → `wait-job`).
+- Universal launcher prefers ts-node when sources present; otherwise uses `dist`.
+- Keep `outputs/` and `config/projects.json` out of git (ignored).
+Create a local `.env.test` file containing your Edge Impulse API key and project IDs. This repository already includes a `./.env.test` for convenience (it is ignored by git). Do NOT commit credentials to source control.

package/README_PROMPTED_STEPS.md

@@ -0,0 +1,79 @@
+**Overview**
+
+- **Purpose**: Document the prompted steps taken to build this framework and provide concise commands to demo it end-to-end.
+
+**Prompted Steps Taken**
+
+- **Initial prompts**: Designed prompts to generate a CLI and helper scripts for interacting with Edge Impulse and LLM integration.
+- **Scaffold CLI**: Implemented a TypeScript CLI (`src/cli.ts`) and server glue (`src/mcp-server.ts`) to expose commands and automated workflows.
+- **Prompt generation**: Added `scripts/generate-prompts.js` and helpers to produce LLM prompts used during assessments and integrations.
+- **Integration scripts**: Created runnable scripts in `scripts/` for recording, assessing, and applying LLM suggestions (`record-and-assess.sh`, `run-llm-iteration.sh`, `apply-llm-suggestions.sh`).
+- **Testing & mocks**: Added tests and a mock server under `test/` to validate CLI behavior (`test/cli.spec.ts`, `test/mock-server.ts`).
+- **Outputs & artifacts**: Results and LLM responses are stored under `outputs/` (e.g., `outputs/llm-responses/` and `outputs/assessments/`).
+
+**Demo: End-to-end Commands**
+
+Prerequisites:
+- Node 18+ and `npm` installed.
+- From the repo root, install deps if needed: `npm install`.
+- Set any required API credentials (Edge Impulse API key or LLM key) in environment variables or pass them as CLI flags.
+
+Quick demo (help):
+
+```bash
+# show CLI help
+npm run cli -- --help
+```
+
+List projects (example):
+
+```bash
+# using --apiKey flag
+npm run cli -- list-projects --apiKey "$EDGE_IMPULSE_API_KEY"
+
+# alternative flag name
+npm run cli -- list-projects --api-key "$EDGE_IMPULSE_API_KEY"
+```
+
+Get all projects (unified option):
+
+```bash
+npm run cli -- get-all-projects --api-key "$EDGE_IMPULSE_API_KEY"
+```
+
+Run an LLM-powered iteration (example script):
+
+```bash
+# run the integration loop that generates prompts, queries LLM, and writes outputs
+./scripts/run-llm-iteration.sh
+```
+
+Run prompt tests (examples):
+
+```bash
+# run prompt test harness
+./scripts/run-prompt-tests.sh
+
+# run single test script
+node scripts/llm-runner.js --sample outputs/llm-responses/prompts-ei_...-accuracy.json.response.txt
+```
+
+Inspect outputs:
+
+- **LLM responses**: `outputs/llm-responses/`
+- **Assessments**: `outputs/assessments/`
+- **Integration snapshots**: `outputs/llm-sim-integration/`
+
+**Files Touched / Relevant Paths**
+
+- `src/cli.ts` — main CLI entry
+- `src/mcp-server.ts` — MCP server glue
+- `scripts/` — automation and prompt generation scripts
+- `outputs/` — generated responses and assessment artifacts
+- `test/` — unit and integration tests
+
+**Next Steps / Notes**
+
+- Replace demo environment variables with real API keys before running.
+- To run full automated assessments, ensure the Edge Impulse project IDs and credentials are configured in `config/` or passed via flags.
+- If you want, I can also add a short shell script that runs the full demo in sequence and collects outputs.

package/check-keras-block-accuracy.ts

@@ -0,0 +1,36 @@
+import fetch from 'node-fetch';
+
+async function getKerasBlockEvaluation(apiKey: string, projectId: string, learnId: string) {
+  const url = `https://studio.edgeimpulse.com/v1/api/${projectId}/training/keras/${learnId}`;
+  const response = await fetch(url, {
+    headers: {
+      'x-api-key': apiKey,
+      'Content-Type': 'application/json',
+    },
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`API error: ${response.status} ${response.statusText}\n${errorText}`);
+  }
+  return response.json();
+}
+
+(async () => {
+  const apiKey = 'ei_00f1f4cd29c8f2254d4793cf6736e66501456bb809036099246a4ecb5cb28ff9';
+  const projectId = '814590';
+  const learnId = '50';
+  try {
+    const result = await getKerasBlockEvaluation(apiKey, projectId, learnId);
+    console.log('Keras Block Evaluation Metrics:');
+    console.log(JSON.stringify(result, null, 2));
+    if (result.accuracy !== undefined) {
+      console.log(`\nAccuracy: ${result.accuracy}`);
+    } else if (result.metrics && result.metrics.accuracy !== undefined) {
+      console.log(`\nAccuracy: ${result.metrics.accuracy}`);
+    } else {
+      console.log('\nAccuracy metric not found in response.');
+    }
+  } catch (err) {
+    console.error('Error fetching Keras block evaluation:', err);
+  }
+})();

package/claude-config-example.json

@@ -0,0 +1,17 @@
+# Claude Desktop Configuration for Edge Impulse MCP Server
+
+# This configuration allows Claude to connect to your Edge Impulse API MCP server
+# Save this as ~/Library/Application Support/Claude/claude_desktop_config.json on macOS
+
+{
+  "mcpServers": {
+    "edge-impulse": {
+      "command": "node",
+      "args": ["/Users/eoinjordan/git/ei-agentic-claude/dist/mcp-server.js"],
+      "cwd": "/Users/eoinjordan/git/ei-agentic-claude",
+      "env": {
+        "NODE_ENV": "production"
+      }
+    }
+  }
+}

package/launch-cli.mjs

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+
+// This launcher detects if running from TypeScript (ts-node) or from compiled JS (Node.js)
+// and loads the correct CLI entrypoint with the right import extension.
+
+const isTsNode = process.argv[1] && process.argv[1].endsWith('.ts');
+
+if (isTsNode) {
+  // Running with ts-node: use .ts extension
+  import('./src/cli.ts');
+} else {
+  // Running with node: use .js extension
+  import('./dist/cli.js');
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "ei-agentic-claude",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "src/cli.ts",
+  "bin": {
+    "cli": "./src/cli.ts"
+  },
+  "scripts": {
+    "cli": "ts-node-esm src/cli.ts",
+    "build": "tsc && node scripts/fix-dist-imports.js && node scripts/generate-integrity-dist.js",
+    "build:tsc": "tsc",
+    "generate-integrity": "node src/postman/edge-impulse/generate-integrity.js",
+    "test": "vitest run --testTimeout=30000",
+    "test:unittests": "node scripts/test-reporter.js",
+    "list-apis": "node scripts/list-apis.js",
+    "smoke": "node ./scripts/smoke-test.js",
+    "mcp-server": "node dist/mcp-server.js",
+    "test-mcp": "node scripts/test-mcp-simple.js",
+    "docker:test": "bash ./scripts/docker-test.sh"
+    ,"project:test": "bash ./scripts/run-project-tests.sh"
+     ,"assess:projects": "bash ./scripts/record-and-assess.sh"
+    ,"prompt:test": "bash ./scripts/run-prompt-tests.sh"
+    ,"llm:run": "node scripts/llm-runner.js"
+    ,"llm:sim": "node scripts/llm-runner-sim.js"
+    ,"test:apply-flow": "bash ./scripts/test-apply-flow.sh"
+    ,"configure:projects": "node scripts/configure-org-projects.js"
+    ,"llm:integration-sim": "node scripts/llm-integration-sim.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.25.3",
+    "commander": "^11.0.0"
+  },
+  "devDependencies": {
+    "ts-node": "^10.9.1",
+    "typescript": "^5.0.0",
+    "vitest": "^1.0.0"
+  }
+}

package/scripts/apply-llm-suggestions.sh

@@ -0,0 +1,39 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Applies LLM-suggested CLI commands saved by scripts/llm-runner.js
+# Defaults to dry-run: to actually execute commands set APPLY_MODE=apply
+
+ROOT_DIR=$(cd "$(dirname "$0")/.." && pwd)
+cd "$ROOT_DIR"
+
+set -o allexport
+source ./.env.test 2>/dev/null || true
+set +o allexport
+
+APPLY_MODE=${APPLY_MODE:-dry}
+PLACEHOLDER_LEARN_ID=${PLACEHOLDER_LEARN_ID:-}
+
+OUT_DIR=outputs/apply-commands
+mkdir -p "$OUT_DIR"
+
+shopt -s nullglob
+for f in outputs/apply-commands/*.sh; do
+  echo "---"
+  echo "Found suggestion: $f"
+  cmd=$(sed -n '1,200p' "$f" | sed -n '1,200p' | tail -n +1)
+  # perform simple placeholder replacement
+  if [[ -n "$PLACEHOLDER_LEARN_ID" ]]; then
+    cmd=$(echo "$cmd" | sed "s/<learnId>/$PLACEHOLDER_LEARN_ID/g")
+  fi
+
+  if [[ "$APPLY_MODE" = "apply" ]]; then
+    echo "Executing: $cmd"
+    eval "$cmd"
+  else
+    echo "Dry-run (to apply set APPLY_MODE=apply):"
+    echo "$cmd"
+  fi
+done
+
+echo "Done. Processed apply suggestions in $OUT_DIR"