ei-agentic-claude 1.0.0

package/scripts/llm-runner.js

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+import fs from 'fs/promises'
+import path from 'path'
+
+const OUTDIR = 'outputs/llm-responses'
+const APPLY_DIR = 'outputs/apply-commands'
+
+function sleep(ms){ return new Promise(r=>setTimeout(r, ms)) }
+
+async function main(){
+  const envPath = './.env.test'
+  try{
+    await fs.access(envPath)
+    const env = await fs.readFile(envPath,'utf8')
+    env.split(/\n/).forEach(line=>{
+      const m = line.match(/^\s*([A-Z0-9_]+)=(.*)$/)
+      if(m) process.env[m[1]] = m[2]
+    })
+  }catch(e){}
+
+  const apiKey = process.env.ANTHROPIC_API_KEY
+  const model = process.env.ANTHROPIC_MODEL || 'claude-2'
+  const anthroVersion = process.env.ANTHROPIC_VERSION || '2023-10-24'
+  if(!apiKey){
+    console.error('Missing ANTHROPIC_API_KEY in environment or .env.test; aborting.')
+    process.exit(2)
+  }
+
+  await fs.mkdir(OUTDIR, { recursive: true })
+  await fs.mkdir(APPLY_DIR, { recursive: true })
+
+  const files = (await fs.readdir('/tmp')).filter(f=>f.startsWith('prompts-') && f.endsWith('.json'))
+  if(files.length===0){
+    console.error('No prompt files found in /tmp (expected /tmp/prompts-<projectId>-<goal>.json).')
+    process.exit(1)
+  }
+
+  for(const f of files){
+    try{
+      const p = path.join('/tmp', f)
+      const content = await fs.readFile(p, 'utf8')
+      let parsed
+      try{ parsed = JSON.parse(content) }catch(e){ parsed = {prompt: content} }
+      const promptText = parsed.prompt || JSON.stringify(parsed, null, 2)
+
+      console.log('Calling Anthropic for', f)
+      const body = {
+        model,
+        prompt: `\n\nHuman: ${promptText}\n\nAssistant:`,
+        max_tokens: 800,
+        temperature: 0.2,
+      }
+
+      // retry logic for transient network errors / rate limits
+      const maxRetries = 5
+      let attempt = 0
+      let res, dataText, jsonData
+      while(attempt < maxRetries){
+        try{
+          res = await fetch('https://api.anthropic.com/v1/complete', {
+            method: 'POST',
+            headers: {
+              'Content-Type': 'application/json',
+              'x-api-key': apiKey,
+              'anthropic-version': anthroVersion,
+            },
+            body: JSON.stringify(body),
+          })
+
+          dataText = await res.text()
+          try{ jsonData = JSON.parse(dataText) }catch(e){ jsonData = null }
+
+          if(res.ok) break
+          // non-ok responses: may be rate limit or invalid key
+          console.error('Non-OK response from Anthropic:', res.status, dataText)
+          if(res.status >= 400 && res.status < 500) break
+        }catch(e){
+          console.error('Fetch error:', e && e.code ? e.code : e.message || e)
+        }
+
+        attempt++
+        const backoff = Math.min(1000 * 2 ** attempt, 30000)
+        console.log(`Retrying in ${backoff}ms (attempt ${attempt}/${maxRetries})`)
+        await sleep(backoff)
+      }
+
+      if(!res){
+        console.error('Failed to get a response from Anthropic after retries for', f)
+        continue
+      }
+
+      const outPath = path.join(OUTDIR, f + '.response.txt')
+      await fs.writeFile(outPath, dataText || '', 'utf8')
+
+      // extract textual completion
+      const completion = (jsonData && (jsonData.completion || jsonData.completion_text || jsonData.text)) || dataText || ''
+
+      // try to extract an apply_cli command from completion
+      const m = completion.match(/apply_cli\s*[:=]\s*`([^`]*)`/i) || completion.match(/apply_cli\s*[:=]\s*"([^"]*)"/i) || completion.match(/apply_cli\s*[:=]\s*(.+)/i)
+      if(m){
+        const cmd = m[1].trim()
+        const applyPath = path.join(APPLY_DIR, f + '.sh')
+        await fs.writeFile(applyPath, '#!/usr/bin/env bash\nset -euo pipefail\n\n# Suggested command from LLM\n' + cmd + '\n', 'utf8')
+        await fs.chmod(applyPath, 0o750)
+        console.log('Saved apply command to', applyPath)
+      }
+
+      console.log('Saved response to', outPath)
+    }catch(err){
+      console.error('Error processing', f, err)
+    }
+  }
+}
+
+main().catch(err=>{ console.error(err); process.exit(1) })

package/scripts/record-and-assess.sh

@@ -0,0 +1,70 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)
+cd "$ROOT_DIR"
+
+ENV_FILE=.env.test
+if [ ! -f "$ENV_FILE" ]; then
+  echo "Error: $ENV_FILE not found. Create it from .env.test and keep it out of version control." >&2
+  exit 2
+fi
+
+# Load env
+set -o allexport
+source "$ENV_FILE"
+set +o allexport
+
+TIMESTAMP=$(date -u +%Y%m%dT%H%M%SZ)
+
+OUTDIR=outputs/assessments
+mkdir -p "$OUTDIR"
+
+PROJECTS=("$PROJECT_888999_ID" "$PROJECT_888996_ID" "$PROJECT_888995_ID")
+
+echo "[record-and-assess] Building project..."
+npm run build
+
+for pid in "${PROJECTS[@]}"; do
+  safe=$(echo "$pid" | tr ':' '_' | tr '/' '_')
+  workdir="$OUTDIR/${safe}_${TIMESTAMP}"
+  mkdir -p "$workdir"
+
+  before="$workdir/before.json"
+  after="$workdir/after.json"
+  report="$workdir/assessment.json"
+
+  echo "[record-and-assess] Fetching baseline for ${pid} -> ${before}"
+  node dist/cli.js get-project --api-key "$EI_API_KEY" --params "{\"projectId\": \"${pid}\"}" > "$before" 2>/tmp/record-err.log || true
+  # Validate JSON; if invalid or empty, write placeholder so assessment can continue
+  if ! node -e "const fs=require('fs'); try{const j=JSON.parse(fs.readFileSync(process.argv[1],'utf8')); console.log('ok');}catch(e){process.exit(1);} " "$before" 2>/dev/null; then
+    echo "[record-and-assess] Baseline output invalid or empty; writing placeholder"
+    cat > "$before" <<JSON
+{"id":"${pid}","name":"Project ${pid}","impulse":{}}
+JSON
+  fi
+
+  echo "[record-and-assess] --- BASELINE saved. You can run apply commands now (or let script run none)."
+  # For automated runs we take a short pause to allow manual/automated interventions
+  sleep 1
+
+  # No automatic apply by default. If user sets APPLY_CLI env var, run it.
+  if [ -n "${APPLY_CLI:-}" ]; then
+    echo "[record-and-assess] Running apply command: ${APPLY_CLI}"
+    eval "$APPLY_CLI" || echo "apply command failed" >&2
+  fi
+
+  echo "[record-and-assess] Fetching post-change snapshot for ${pid} -> ${after}"
+  node dist/cli.js get-project --api-key "$EI_API_KEY" --params "{\"projectId\": \"${pid}\"}" > "$after" 2>/tmp/record-err2.log || true
+  if ! node -e "const fs=require('fs'); try{const j=JSON.parse(fs.readFileSync(process.argv[1],'utf8')); console.log('ok');}catch(e){process.exit(1);} " "$after" 2>/dev/null; then
+    echo "[record-and-assess] After snapshot invalid or empty; writing placeholder"
+    cat > "$after" <<JSON
+{"id":"${pid}","name":"Project ${pid}","impulse":{}}
+JSON
+  fi
+
+  echo "[record-and-assess] Running assessment..."
+  node ./scripts/assess.js "$before" "$after" "$report"
+done
+
+echo "[record-and-assess] All assessments written to $OUTDIR"

package/scripts/run-llm-iteration.sh

@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Wrapper to run the LLM iteration using prompts in /tmp
+if [ -f ./.env.test ]; then
+  set -o allexport
+  source ./.env.test
+  set +o allexport
+fi
+
+if [ -z "${ANTHROPIC_API_KEY:-}" ]; then
+  echo "Missing ANTHROPIC_API_KEY in environment or ./.env.test. Add it and retry." >&2
+  exit 2
+fi
+
+node scripts/llm-runner.js

package/scripts/run-project-tests.sh

@@ -0,0 +1,80 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)
+cd "$ROOT_DIR"
+
+ENV_FILE=.env.test
+if [ ! -f "$ENV_FILE" ]; then
+  echo "Error: $ENV_FILE not found. Create it from .env.test and keep it out of version control." >&2
+  exit 2
+fi
+
+# Load env file without printing secrets
+set -o allexport
+source "$ENV_FILE"
+set +o allexport
+
+echo "[run-project-tests] Building project to generate runtime artifacts..."
+
+# Build TypeScript to dist so Node can run compiled JS
+npm run build
+
+# Default timeout (seconds) for each CLI invocation to avoid hangs
+TIMEOUT="${TIMEOUT:-60}"
+timeout_exec() {
+  perl -e 'alarm shift @ARGV; exec @ARGV' "$@"
+}
+
+echo "[run-project-tests] Using project IDs (not displaying API key):"
+echo " - PROJECT_888999_ID=${PROJECT_888999_ID}"
+echo " - PROJECT_888996_ID=${PROJECT_888996_ID}"
+echo " - PROJECT_888995_ID=${PROJECT_888995_ID}"
+
+FAIL=0
+
+run_get_project() {
+  local pid=$1
+  echo "[run-project-tests] Querying project ${pid}..."
+  # Optionally run inside Docker for isolated test runs
+  if [ "${RUN_IN_DOCKER:-}" = "true" ]; then
+    CONTAINER=test-project-runner-$$
+    echo "[run-project-tests] Starting helper container ${CONTAINER}..."
+    docker run --rm -d --name "${CONTAINER}" \
+      -e EI_API_KEY="${EI_API_KEY}" \
+      -e ORG_EI_API_KEY="${ORG_EI_API_KEY:-}" \
+      -e PROJECT_888999_ID="${PROJECT_888999_ID}" \
+      -e PROJECT_888996_ID="${PROJECT_888996_ID}" \
+      -e PROJECT_888995_ID="${PROJECT_888995_ID}" \
+      ei-agentic-claude:latest tail -f /dev/null >/dev/null
+    if docker exec "${CONTAINER}" sh -c "perl -e 'alarm ${TIMEOUT}; exec @ARGV' node dist/cli.js get-project --api-key '${EI_API_KEY}' --params '{\"projectId\": \"${pid}\"}'" >/tmp/run-project-output.json 2>/tmp/run-project-err.log; then
+      echo "[run-project-tests] OK: ${pid} -> output saved to /tmp/run-project-output.json"
+      docker rm -f "${CONTAINER}" >/dev/null 2>&1 || true
+    else
+      echo "[run-project-tests] ERROR querying ${pid}; see /tmp/run-project-err.log" >&2
+      cat /tmp/run-project-err.log >&2 || true
+      docker rm -f "${CONTAINER}" >/dev/null 2>&1 || true
+      FAIL=1
+    fi
+  else
+    # Use the generated CLI command locally; do not print the API key
+    if timeout_exec "$TIMEOUT" node dist/cli.js get-project --api-key "$EI_API_KEY" --params "{\"projectId\": \"${pid}\"}" >/tmp/run-project-output.json 2>/tmp/run-project-err.log; then
+      echo "[run-project-tests] OK: ${pid} -> output saved to /tmp/run-project-output.json"
+    else
+      echo "[run-project-tests] ERROR querying ${pid}; see /tmp/run-project-err.log" >&2
+      cat /tmp/run-project-err.log >&2 || true
+      FAIL=1
+    fi
+  fi
+}
+
+run_get_project "$PROJECT_888999_ID"
+run_get_project "$PROJECT_888996_ID"
+run_get_project "$PROJECT_888995_ID"
+
+if [ "$FAIL" -ne 0 ]; then
+  echo "[run-project-tests] One or more project queries failed." >&2
+  exit 3
+fi
+
+echo "[run-project-tests] All project queries completed successfully."

package/scripts/run-prompt-tests-sh.sh

@@ -0,0 +1,43 @@
+#!/bin/sh
+# POSIX-compatible prompt test runner for use inside minimal containers
+set -eu
+ROOT_DIR=$(cd "$(dirname "$0")/.." && pwd)
+cd "$ROOT_DIR"
+
+echo "[run-prompt-tests-sh] Ensuring built artifacts..."
+if [ -d dist ]; then
+  echo "[run-prompt-tests-sh] Found existing /app/dist — skipping build"
+else
+  echo "[run-prompt-tests-sh] Building project (dist not found)..."
+  npm run build
+fi
+
+if [ -z "${PROJECT_888999_ID:-}" ] || [ -z "${PROJECT_888996_ID:-}" ] || [ -z "${PROJECT_888995_ID:-}" ]; then
+  echo "One or more PROJECT_* env vars missing; ensure .env.test is mounted into /app/.env.test" >&2
+  exit 2
+fi
+
+echo "[run-prompt-tests-sh] Fetching projects..."
+node dist/cli.js get-project --api-key "$EI_API_KEY" --params "{\"projectId\": \"$PROJECT_888999_ID\"}" > "/tmp/project-$PROJECT_888999_ID.json" 2>/tmp/run-prompt-err.log || true
+node dist/cli.js get-project --api-key "$EI_API_KEY" --params "{\"projectId\": \"$PROJECT_888996_ID\"}" > "/tmp/project-$PROJECT_888996_ID.json" 2>/tmp/run-prompt-err.log || true
+node dist/cli.js get-project --api-key "$EI_API_KEY" --params "{\"projectId\": \"$PROJECT_888995_ID\"}" > "/tmp/project-$PROJECT_888995_ID.json" 2>/tmp/run-prompt-err.log || true
+
+# Ensure files minimally valid JSON
+for f in /tmp/project-*.json; do
+  if [ ! -f "$f" ]; then
+    echo "Missing expected project file: $f" >&2
+    exit 1
+  fi
+  first=$(dd if="$f" bs=1 count=1 2>/dev/null || true)
+  case "$first" in
+    '{') ;;
+    *) echo "Warning: $f does not start with '{' - placeholder will be created" >&2; pid=$(basename "$f" | sed -E 's/^project-(.*)\.json$/\1/'); cat > "$f" <<JSON
+{"id":"$pid","name":"Project $pid","impulse":{}}
+JSON
+  esac
+done
+
+echo "[run-prompt-tests-sh] Generating prompts..."
+node ./scripts/generate-prompts.js /tmp/project-$PROJECT_888999_ID.json /tmp/project-$PROJECT_888996_ID.json /tmp/project-$PROJECT_888995_ID.json
+
+echo "[run-prompt-tests-sh] Done. Prompts in /tmp"

package/scripts/run-prompt-tests.sh

@@ -0,0 +1,53 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)
+cd "$ROOT_DIR"
+
+ENV_FILE=.env.test
+if [ ! -f "$ENV_FILE" ]; then
+  echo "Error: $ENV_FILE not found. Create it from .env.test and keep it out of version control." >&2
+  exit 2
+fi
+
+# Load env (Edge Impulse key required)
+set -o allexport
+source "$ENV_FILE"
+set +o allexport
+
+echo "[run-prompt-tests] Building project..."
+npm run build
+
+# Default timeout (seconds) for each CLI invocation to avoid hangs
+TIMEOUT="${TIMEOUT:-60}"
+timeout_exec() {
+  perl -e 'alarm shift @ARGV; exec @ARGV' "$@"
+}
+
+PROJECTS=("$PROJECT_888999_ID" "$PROJECT_888996_ID" "$PROJECT_888995_ID")
+
+for pid in "${PROJECTS[@]}"; do
+  outfile="/tmp/project-${pid}.json"
+  echo "[run-prompt-tests] Fetching project ${pid} -> ${outfile}"
+  timeout_exec "$TIMEOUT" node dist/cli.js get-project --api-key "$EI_API_KEY" --params "{\"projectId\": \"${pid}\"}" > "$outfile" 2>/tmp/run-prompt-err.log || true
+  # Validate JSON
+  if ! head -c 1 "$outfile" | grep -q '{'; then
+    echo "[run-prompt-tests] Warning: output for ${pid} does not look like JSON — saving placeholder and continuing." >&2
+    sed -n '1,200p' /tmp/run-prompt-err.log >&2 || true
+    # Create a minimal placeholder JSON so prompts can still be generated
+    cat > "$outfile" <<JSON
+{"id":"${pid}","name":"Project ${pid}","impulse":{}}
+JSON
+  fi
+done
+
+echo "[run-prompt-tests] Generating prompts from project JSONs..."
+node ./scripts/generate-prompts.js /tmp/project-${PROJECT_888999_ID}.json /tmp/project-${PROJECT_888996_ID}.json /tmp/project-${PROJECT_888995_ID}.json
+
+echo "[run-prompt-tests] Generated prompts saved under /tmp/prompts-<projectId>.json"
+
+if [ -n "${ANTHROPIC_API_KEY:-}" ]; then
+  echo "[run-prompt-tests] ANTHROPIC_API_KEY detected — sending prompts to Anthropic is optional and not yet implemented in this runner. Use /tmp/prompts-<projectId>.json files to call the LLM API."
+fi
+
+echo "[run-prompt-tests] Done."

package/scripts/smoke-test.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+import { execFileSync } from 'child_process';
+import path from 'path';
+
+function run(cmd, args = []){
+  try{
+    const out = execFileSync(cmd, args, { encoding: 'utf8' });
+    return { ok: true, out };
+  }catch(e){
+    return { ok: false, out: e.stdout ? e.stdout.toString() : '', err: e };
+  }
+}
+
+const launcher = path.resolve(path.dirname(new URL(import.meta.url).pathname), '..', 'launch-cli.mjs');
+
+console.log('Running smoke tests...');
+
+const checks = [
+  {
+    name: 'top-level help',
+    cmd: process.execPath,
+    args: [launcher, '--help'],
+    expect: /train-model-keras|retrain|wait-job/
+  },
+  {
+    name: 'train-model-keras help',
+    cmd: process.execPath,
+    args: [launcher, 'train-model-keras', '--help'],
+    expect: /Auto-generated command for train_model_keras|--projectId|--learnId/
+  },
+  {
+    name: 'wait-job help',
+    cmd: process.execPath,
+    args: [launcher, 'wait-job', '--help'],
+    expect: /Poll a job until completion|--projectId|--jobId/
+  }
+];
+
+let failed = false;
+for(const check of checks){
+  process.stdout.write(`- ${check.name}... `);
+  const res = run(check.cmd, check.args);
+  if(!res.ok){
+    console.log('FAILED (process error)');
+    console.error(res.err && res.err.message ? res.err.message : 'no error message');
+    failed = true;
+    continue;
+  }
+  if(!check.expect.test(res.out)){
+    console.log('FAILED (output did not match)');
+    console.log('--- stdout ---');
+    console.log(res.out);
+    failed = true;
+    continue;
+  }
+  console.log('OK');
+}
+
+if(failed){
+  console.error('Smoke tests failed');
+  process.exit(2);
+}
+console.log('All smoke tests passed');
+process.exit(0);

package/scripts/test-apply-flow.sh

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)
+cd "$ROOT_DIR"
+
+echo "[test-apply-flow] Ensuring prompts exist..."
+npm run prompt:test
+
+echo "[test-apply-flow] Running simulated LLM runner..."
+node scripts/llm-runner-sim.js
+
+echo "[test-apply-flow] Listing simulated responses and apply scripts:"
+ls -la outputs/llm-responses || true
+ls -la outputs/apply-commands || true
+
+echo "[test-apply-flow] Dry-run apply of simulated suggestions:"
+./scripts/apply-llm-suggestions.sh
+
+echo "[test-apply-flow] Done. Inspect outputs/apply-commands and outputs/llm-responses"

package/scripts/test-mcp-simple.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+// Simple MCP server test
+import { spawn } from 'child_process';
+
+console.log('🧪 Testing Edge Impulse MCP Server...\n');
+
+const mcpProcess = spawn('node', ['dist/mcp-server.js'], {
+  stdio: ['pipe', 'pipe', 'inherit'],
+  cwd: process.cwd()
+});
+
+// Test 1: List tools
+const listToolsRequest = {
+  jsonrpc: '2.0',
+  id: 1,
+  method: 'tools/list',
+  params: {}
+};
+
+setTimeout(() => {
+  console.log('📋 Requesting tool list...');
+  mcpProcess.stdin.write(JSON.stringify(listToolsRequest) + '\n');
+
+  mcpProcess.stdout.on('data', (data) => {
+    try {
+      const response = JSON.parse(data.toString());
+      if (response.result && response.result.tools) {
+        console.log(`✅ Successfully loaded ${response.result.tools.length} Edge Impulse API tools!`);
+        console.log('\n🎉 MCP Server is working correctly!');
+        console.log('\n📖 Next steps:');
+        console.log('1. Configure Claude Desktop with the MCP server');
+        console.log('2. Ask Claude to interact with Edge Impulse APIs naturally');
+        console.log('3. Example: "List all my Edge Impulse projects"');
+
+        mcpProcess.kill();
+        process.exit(0);
+      }
+    } catch (e) {
+      // Ignore parsing errors for large responses
+    }
+  });
+}, 1000);
+
+// Timeout after 5 seconds
+setTimeout(() => {
+  console.log('❌ Test timeout - MCP server may not be responding');
+  mcpProcess.kill();
+  process.exit(1);
+}, 5000);

package/scripts/test-mcp.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+
+// Test script to verify MCP server functionality
+import { spawn } from 'child_process';
+import path from 'path';
+
+const mcpServerPath = path.resolve('./dist/mcp-server.js');
+
+console.log('Testing Edge Impulse MCP Server...\n');
+
+// Test 1: List tools
+console.log('1. Testing tool listing...');
+const listToolsProcess = spawn('node', [mcpServerPath], {
+  stdio: ['pipe', 'pipe', 'pipe'],
+  cwd: process.cwd()
+});
+
+const listToolsRequest = {
+  jsonrpc: '2.0',
+  id: 1,
+  method: 'tools/list',
+  params: {}
+};
+
+listToolsProcess.stdin.write(JSON.stringify(listToolsRequest) + '\n');
+listToolsProcess.stdout.on('data', (data) => {
+  console.log('✓ Tools list received');
+  console.log('Sample tools:', JSON.parse(data.toString()).result.tools.slice(0, 3).map(t => t.name));
+});
+
+listToolsProcess.stderr.on('data', (data) => {
+  console.error('Error:', data.toString());
+});
+
+// Wait a bit then test a tool call
+setTimeout(() => {
+  console.log('\n2. Testing tool call (get_current_user)...');
+
+  const toolCallProcess = spawn('node', [mcpServerPath], {
+    stdio: ['pipe', 'pipe', 'pipe'],
+    cwd: process.cwd()
+  });
+
+  const toolCallRequest = {
+    jsonrpc: '2.0',
+    id: 2,
+    method: 'tools/call',
+    params: {
+      name: 'get_current_user',
+      arguments: {
+        apiKey: 'test-key-for-demo'
+      }
+    }
+  };
+
+  toolCallProcess.stdin.write(JSON.stringify(toolCallRequest) + '\n');
+  toolCallProcess.stdout.on('data', (data) => {
+    console.log('✓ Tool call response received');
+    console.log('Response preview:', data.toString().substring(0, 100) + '...');
+  });
+
+  toolCallProcess.stderr.on('data', (data) => {
+    console.error('Error:', data.toString());
+  });
+
+  // Clean exit after test
+  setTimeout(() => {
+    listToolsProcess.kill();
+    toolCallProcess.kill();
+    console.log('\n✓ MCP Server test completed successfully!');
+    console.log('\nNext steps:');
+    console.log('1. Set up Claude Desktop configuration');
+    console.log('2. Start using Edge Impulse APIs through Claude!');
+  }, 2000);
+
+}, 1000);