ei-agentic-claude 1.0.0

package/scripts/assess.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+
+function loadJson(p) {
+  try {
+    return JSON.parse(fs.readFileSync(p, 'utf8'));
+  } catch (e) {
+    console.error('Failed to load JSON', p, e.message);
+    process.exit(2);
+  }
+}
+
+function collectMetrics(obj, prefix = '') {
+  const metrics = {};
+  if (obj && typeof obj === 'object') {
+    for (const k of Object.keys(obj)) {
+      const v = obj[k];
+      const key = prefix ? `${prefix}.${k}` : k;
+      if (typeof v === 'number') {
+        if (/acc|accuracy|f1|precision|recall|auc|score|loss/i.test(k)) {
+          metrics[key] = v;
+        }
+      } else if (typeof v === 'object') {
+        Object.assign(metrics, collectMetrics(v, key));
+      }
+    }
+  }
+  return metrics;
+}
+
+function diffMetrics(before, after) {
+  const keys = new Set([...Object.keys(before), ...Object.keys(after)]);
+  const diffs = [];
+  for (const k of keys) {
+    const bv = before[k];
+    const av = after[k];
+    if (bv === undefined && av !== undefined) diffs.push({ key: k, before: null, after: av });
+    else if (av === undefined && bv !== undefined) diffs.push({ key: k, before: bv, after: null });
+    else if (typeof bv === 'number' && typeof av === 'number' && bv !== av) diffs.push({ key: k, before: bv, after: av, delta: av - bv });
+  }
+  return diffs;
+}
+
+function collectBlocks(project) {
+  // try common locations
+  const blocks = project?.impulse?.blocks || project?.impulse?.configuration?.blocks || null;
+  return blocks || null;
+}
+
+function diffBlocks(beforeBlocks, afterBlocks) {
+  if (!beforeBlocks && !afterBlocks) return { changed: false, details: [] };
+  const details = [];
+  const byName = (arr) => (arr || []).reduce((m, b) => { m[b.name || b.id || JSON.stringify(b)] = b; return m; }, {});
+  const bBefore = byName(beforeBlocks || []);
+  const bAfter = byName(afterBlocks || []);
+  const keys = new Set([...Object.keys(bBefore), ...Object.keys(bAfter)]);
+  for (const k of keys) {
+    const bb = bBefore[k];
+    const ba = bAfter[k];
+    if (!bb) details.push({ name: k, type: 'added', after: ba });
+    else if (!ba) details.push({ name: k, type: 'removed', before: bb });
+    else if (JSON.stringify(bb) !== JSON.stringify(ba)) details.push({ name: k, type: 'modified', before: bb, after: ba });
+  }
+  return { changed: details.length > 0, details };
+}
+
+function main() {
+  const [,, beforePath, afterPath, outPath] = process.argv;
+  if (!beforePath || !afterPath || !outPath) {
+    console.error('Usage: assess.js <before.json> <after.json> <out.json>');
+    process.exit(2);
+  }
+
+  const before = loadJson(beforePath);
+  const after = loadJson(afterPath);
+
+  const beforeMetrics = collectMetrics(before);
+  const afterMetrics = collectMetrics(after);
+  const metricDiffs = diffMetrics(beforeMetrics, afterMetrics);
+
+  const beforeBlocks = collectBlocks(before);
+  const afterBlocks = collectBlocks(after);
+  const blocksDiff = diffBlocks(beforeBlocks, afterBlocks);
+
+  const report = {
+    beforePath, afterPath,
+    collectedAt: new Date().toISOString(),
+    metricDiffs,
+    blocksDiff
+  };
+
+  fs.writeFileSync(outPath, JSON.stringify(report, null, 2), 'utf8');
+  console.log('Assessment written to', outPath);
+  // Also print concise human report
+  console.log('\nMetric changes:');
+  if (metricDiffs.length === 0) console.log('  No numeric metric changes found');
+  else metricDiffs.forEach(d => console.log(`  ${d.key}: ${d.before} -> ${d.after} (Δ ${d.delta ?? 'n/a'})`));
+
+  console.log('\nBlock changes:');
+  if (!blocksDiff.changed) console.log('  No block-level changes detected');
+  else blocksDiff.details.forEach(d => console.log(`  [${d.type}] ${d.name}`));
+}
+
+main();

package/scripts/configure-org-projects.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+import fs from 'fs/promises'
+import path from 'path'
+
+async function loadEnv(envPath = './.env.test'){
+  try{
+    const data = await fs.readFile(envPath, 'utf8')
+    data.split(/\n/).forEach(line=>{
+      const m = line.match(/^\s*([A-Z0-9_]+)=(.*)$/)
+      if(m) process.env[m[1]] = m[2]
+    })
+  }catch(e){}
+}
+
+async function main(){
+  await loadEnv()
+
+  const apiKey = process.env.EI_API_KEY
+  if(!apiKey){
+    console.error('Missing EI_API_KEY in environment or .env.test; aborting.')
+    process.exit(2)
+  }
+
+  const outDir = 'config'
+  await fs.mkdir(outDir, { recursive: true })
+
+  console.log('Fetching projects from Edge Impulse...')
+  const url = 'https://studio.edgeimpulse.com/v1/api/projects'
+  const res = await fetch(url, { headers: { 'x-api-key': apiKey, 'Content-Type': 'application/json' } })
+  const txt = await res.text()
+  if(!res.ok){
+    console.error('Edge Impulse API returned', res.status)
+    try{ console.error(JSON.parse(txt)) }catch(e){ console.error(txt) }
+    process.exit(3)
+  }
+
+  let data
+  try{ data = JSON.parse(txt) }catch(e){
+    console.error('Failed to parse response JSON')
+    console.error(txt)
+    process.exit(4)
+  }
+
+  const outPath = path.join(outDir, 'projects.json')
+  await fs.writeFile(outPath, JSON.stringify(data, null, 2), 'utf8')
+  console.log(`Wrote ${Object.keys(data).length ? 'projects object' : 'response'} to ${outPath}`)
+
+  if(Array.isArray(data.projects)){
+    console.log(`Found ${data.projects.length} projects; sample:`)
+    console.log(data.projects.slice(0,5).map(p=>({ id: p.id || p.projectId || p._id, name: p.name || p.title })).slice(0,5))
+  }
+
+  console.log('Configuration write complete. Inspect config/projects.json for details.')
+}
+
+main().catch(err=>{ console.error(err); process.exit(1) })

package/scripts/docker-test.sh

@@ -0,0 +1,43 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+IMAGE=ei-agentic-claude:latest
+CONTAINER=test-ei-mcp-$$
+TIMEOUT=30
+
+echo "[docker-test] Building image ${IMAGE}..."
+docker build -t "${IMAGE}" .
+
+echo "[docker-test] Running container ${CONTAINER}..."
+# Pass through .env.test variables if present to support org/project API keys
+ENV_FILE=.env.test
+if [ -f "$ENV_FILE" ]; then
+  # load to export for docker env args
+  set -o allexport
+  source "$ENV_FILE"
+  set +o allexport
+fi
+
+echo "[docker-test] Running 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:-}" \
+  "${IMAGE}"
+
+echo "[docker-test] Waiting up to ${TIMEOUT}s for server to report ready..."
+for i in $(seq 1 ${TIMEOUT}); do
+  if docker logs "${CONTAINER}" 2>&1 | grep -q "Edge Impulse MCP server running on stdio"; then
+    echo "[docker-test] Server started successfully"
+    docker rm -f "${CONTAINER}" >/dev/null 2>&1 || true
+    exit 0
+  fi
+  sleep 1
+done
+
+echo "[docker-test] Server did not start within ${TIMEOUT}s"
+docker logs "${CONTAINER}" || true
+docker rm -f "${CONTAINER}" >/dev/null 2>&1 || true
+exit 2

package/scripts/entrypoint.sh

@@ -0,0 +1,31 @@
+#!/usr/bin/env sh
+# Entrypoint: load env file(s) if present, print readiness, then exec command
+# Looks for /app/.env, /app/.env.test (in that order) and exports variables.
+
+load_env_file(){
+	f="$1"
+	if [ -f "$f" ]; then
+		echo "Loading env from $f"
+		# shellcheck disable=SC1090
+		set -o allexport
+		# read lines and export only simple KEY=VALUE pairs
+		while IFS= read -r line || [ -n "$line" ]; do
+			case "$line" in
+				''|\#*) continue ;;
+			esac
+			if echo "$line" | grep -qE '^[A-Z0-9_]+=.*$'; then
+				k=$(echo "$line" | sed -E 's/=.*$//')
+				v=$(echo "$line" | sed -E 's/^[^=]*=//')
+				export "$k"="$v"
+			fi
+		done < "$f"
+		set +o allexport
+	fi
+}
+
+# Prefer .env.test if present for testing
+load_env_file /app/.env.test
+load_env_file /app/.env
+
+printf "Edge Impulse MCP server running on stdio\n" >&1
+exec "$@"

package/scripts/fix-dist-imports.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const distCli = path.join(__dirname, '..', 'dist', 'cli.js');
+
+if (!fs.existsSync(distCli)) {
+  console.error('dist/cli.js does not exist. Run tsc first.');
+  process.exit(1);
+}
+
+const src = await fs.promises.readFile(distCli, 'utf8');
+
+// Fix local ESM imports that lack .js extension
+let out = src.replace(/from \"\.\/register-generated-commands\";/g, 'from "./register-generated-commands.js";');
+out = out.replace(/from \"\.\/register-generated-commands\"/g, 'from "./register-generated-commands.js"');
+
+await fs.promises.writeFile(distCli, out, 'utf8');
+console.log('Patched dist/cli.js imports.');
+
+// Patch generated CLI command imports to include .js extensions
+const cliCommandsDir = path.join(__dirname, '..', 'dist', 'postman', 'edge-impulse', 'generated', 'cli-commands');
+if (fs.existsSync(cliCommandsDir)) {
+  const files = await fs.promises.readdir(cliCommandsDir);
+  for (const f of files) {
+    if (!f.endsWith('.js')) continue;
+    const p = path.join(cliCommandsDir, f);
+    let c = await fs.promises.readFile(p, 'utf8');
+    // replace from '../some_name' or "../some_name" with ../some_name.js when .js missing
+    c = c.replace(/from\s+(['"])((?:\.\.\/)+[^'"\s]+?)\1/g, (m, quote, rel) => {
+      // only append .js when there's no extension already
+      if (/\.(js|json)$/.test(rel)) return `from ${quote}${rel}${quote}`;
+      return `from ${quote}${rel}.js${quote}`;
+    });
+    await fs.promises.writeFile(p, c, 'utf8');
+  }
+  console.log('Patched generated CLI command imports to use .js extensions.');
+} else {
+  console.warn('CLI commands dir not found; skipping additional patches.');
+}
+
+// Fix any accidental double-quote injection
+const fixFiles = await fs.promises.readdir(cliCommandsDir);
+for (const f of fixFiles) {
+  if (!f.endsWith('.js')) continue;
+  const p = path.join(cliCommandsDir, f);
+  let content = await fs.promises.readFile(p, 'utf8');
+  content = content.replace(/from\s+''\.\.\//g, "from '../");
+  content = content.replace(/from\s+\"\"\.\.\//g, 'from "../');
+  await fs.promises.writeFile(p, content, 'utf8');
+}
+console.log('Cleaned accidental double quotes in CLI command imports.');
+
+// Additionally, patch any remaining relative imports across dist to include .js
+async function patchAllRelativeImports(dir) {
+  const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+  for (const ent of entries) {
+    const p = path.join(dir, ent.name);
+    if (ent.isDirectory()) {
+      await patchAllRelativeImports(p);
+      continue;
+    }
+    if (!ent.isFile() || !p.endsWith('.js')) continue;
+    let c = await fs.promises.readFile(p, 'utf8');
+    const updated = c.replace(/from\s+(['"])((?:\.\.\/|\.\/)+[^'"\s]+?)\1/g, (m, quote, rel) => {
+      if (/\.(js|json)$/.test(rel)) return `from ${quote}${rel}${quote}`;
+      return `from ${quote}${rel}.js${quote}`;
+    });
+    if (updated !== c) await fs.promises.writeFile(p, updated, 'utf8');
+  }
+}
+
+await patchAllRelativeImports(path.join(__dirname, '..', 'dist'));
+console.log('Patched remaining relative imports across dist to include .js extensions.');

package/scripts/generate-integrity-dist.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+
+/**
+ * Generate SHA256 integrity hashes for files in dist/postman/edge-impulse/generated
+ * Writes `integrity.json` into the `cli-commands` folder so the runtime integrity check can use it.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+
+const GENERATED_DIR = path.join(process.cwd(), 'dist', 'postman', 'edge-impulse', 'generated');
+const CLI_COMMANDS_DIR = path.join(GENERATED_DIR, 'cli-commands');
+
+function calculateSHA256(filePath) {
+  const fileBuffer = fs.readFileSync(filePath);
+  const hashSum = crypto.createHash('sha256');
+  hashSum.update(fileBuffer);
+  return hashSum.digest('hex');
+}
+
+function generate() {
+  if (!fs.existsSync(CLI_COMMANDS_DIR)) {
+    console.error('Target generated CLI commands directory not found:', CLI_COMMANDS_DIR);
+    process.exit(1);
+  }
+
+  const files = fs.readdirSync(CLI_COMMANDS_DIR).filter(f => f.endsWith('.js') || f.endsWith('.ts'));
+  const hashes = {};
+
+  for (const file of files) {
+    const p = path.join(CLI_COMMANDS_DIR, file);
+    hashes[file] = calculateSHA256(p);
+  }
+
+  const out = path.join(CLI_COMMANDS_DIR, 'integrity.json');
+  fs.writeFileSync(out, JSON.stringify(hashes, null, 2));
+  console.log('Wrote integrity.json to', out);
+}
+
+generate();

package/scripts/generate-prompts.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+
+function loadProjectJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch (e) {
+    console.error('Failed to load', filePath, e.message);
+    return null;
+  }
+}
+
+function detectImpulseType(project) {
+  // Look for common indicators in project JSON to infer impulse type
+  if (!project) return 'unknown';
+  const name = (project.name || '').toString().toLowerCase();
+  if (name.includes('anomaly')) return 'anomaly';
+  if (name.includes('object-detection') || name.includes('keras-object-detection')) return 'object-detection';
+  if (name.includes('keras')) return 'keras';
+  if (project.impulse && project.impulse.blocks) return 'impulse';
+  if (project.type) return project.type;
+  return 'unknown';
+}
+
+function makePrompts(projectId, projectJson) {
+  const impulseType = detectImpulseType(projectJson);
+  const base = `Project ID: ${projectId}\nSummary: ${projectJson.name || 'Unnamed project'}\n`;
+
+  // Choose prioritized goals depending on impulse type
+  let goalsOrder = ['accuracy', 'latency', 'size', 'robustness'];
+  if (impulseType === 'anomaly') {
+    goalsOrder = ['robustness', 'accuracy', 'size', 'latency'];
+  } else if (impulseType === 'object-detection' || impulseType === 'keras') {
+    goalsOrder = ['accuracy', 'size', 'latency', 'robustness'];
+  }
+
+  const goalDefs = {
+    accuracy: 'Improve accuracy on validation data while keeping training time reasonable.',
+    latency: 'Reduce inference latency on edge devices without losing more than 2% accuracy.',
+    size: 'Reduce model size for deployment to constrained devices.',
+    robustness: 'Improve robustness to noisy inputs and edge-case samples.'
+  };
+
+  return goalsOrder.map(gk => ({
+    id: `${projectId}-${gk}`,
+    goal: gk,
+    prompt: `${base}Impulse type: ${impulseType}\nOptimization goal: ${goalDefs[gk]}\nCurrent impulse (truncated): ${JSON.stringify(projectJson.impulse || {}, null, 2).slice(0, 2000)}\n\nProvide a set of recommended block-level changes (DSP parameters, model selection, training parameters, data augmentation, and evaluation strategy) that can be applied via Edge Impulse APIs to achieve the goal. For each recommendation, include the expected trade-offs and a simple CLI invocation using this repo's CLI to apply or test the change.`
+  }));
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0) {
+    console.error('Usage: generate-prompts.js <project-json-path> [<project-json-path> ...]');
+    process.exit(2);
+  }
+
+  for (const p of args) {
+    const pj = loadProjectJson(p);
+    if (!pj) continue;
+    const projectId = pj.id || pj.projectId || path.basename(p).replace(/\.json$/, '');
+    const prompts = makePrompts(projectId, pj);
+    // Write one file per goal so iterative testing can be targeted
+    for (const pr of prompts) {
+      const out = `/tmp/prompts-${projectId}-${pr.goal}.json`;
+      // Add an example 'apply_cli' suggestion depending on goal
+      pr.apply_cli = (() => {
+        switch (pr.goal) {
+          case 'accuracy':
+            return `node dist/cli.js train-model-keras --api-key $EI_API_KEY --params '{"projectId":"${projectId}","learnId":<learnId>,"epochs":20}'`;
+          case 'latency':
+            return `node dist/cli.js optimize-model --api-key $EI_API_KEY --params '{"projectId":"${projectId}","versionId":<versionId>,"target":"tflite"}'`;
+          case 'size':
+            return `node dist/cli.js build-on-device-model --api-key $EI_API_KEY --params '{"projectId":"${projectId}","target":"npu"}'`;
+          case 'robustness':
+            return `node dist/cli.js generate-data-explorer-features --api-key $EI_API_KEY --params '{"projectId":"${projectId}"}'`;
+          default:
+            return '';
+        }
+      })();
+
+      fs.writeFileSync(out, JSON.stringify(pr, null, 2), 'utf8');
+      console.log('Wrote', out);
+    }
+  }
+}
+
+main();

package/scripts/list-apis.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+function listAllAPIs() {
+  const apiDir = path.resolve(__dirname, '../src/postman/edge-impulse/generated');
+
+  if (!fs.existsSync(apiDir)) {
+    console.error('API directory not found');
+    process.exit(1);
+  }
+
+  const apiFiles = fs.readdirSync(apiDir)
+    .filter(f => f.endsWith('.ts') && !f.includes('cli-commands'))
+    .map(f => f.replace('.ts', ''))
+    .sort();
+
+  console.log(`Total APIs: ${apiFiles.length}\n`);
+
+  // Group by category
+  const categories = {
+    projects: apiFiles.filter(f => f.includes('project')),
+    users: apiFiles.filter(f => f.includes('user')),
+    jobs: apiFiles.filter(f => f.includes('job')),
+    training: apiFiles.filter(f => f.includes('train') || f.includes('keras') || f.includes('optimize') || f.includes('retrain')),
+    data: apiFiles.filter(f => f.includes('data') || f.includes('sample') || f.includes('dataset')),
+    organizations: apiFiles.filter(f => f.includes('organization')),
+    deployments: apiFiles.filter(f => f.includes('deploy')),
+    dsp: apiFiles.filter(f => f.includes('dsp')),
+    evaluation: apiFiles.filter(f => f.includes('evaluate')),
+    files: apiFiles.filter(f => f.includes('file') || f.includes('upload') || f.includes('download')),
+    admin: apiFiles.filter(f => f.includes('admin') || f.includes('white_label') || f.includes('theme')),
+    auth: apiFiles.filter(f => f.includes('auth') || f.includes('login') || f.includes('token')),
+    models: apiFiles.filter(f => f.includes('model') || f.includes('impulse')),
+    devices: apiFiles.filter(f => f.includes('device')),
+    pipelines: apiFiles.filter(f => f.includes('pipeline')),
+    notifications: apiFiles.filter(f => f.includes('notification') || f.includes('email')),
+    metrics: apiFiles.filter(f => f.includes('metric')),
+  };
+
+  // Add uncategorized to 'other'
+  const categorized = Object.values(categories).flat();
+  categories.other = apiFiles.filter(api => !categorized.includes(api));
+
+  for (const [category, apis] of Object.entries(categories)) {
+    if (apis.length > 0) {
+      console.log(`${category.toUpperCase()} (${apis.length}):`);
+      apis.forEach(api => console.log(`  - ${api}`));
+      console.log('');
+    }
+  }
+}
+
+listAllAPIs();

package/scripts/llm-integration-sim.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+import fs from 'fs/promises'
+import path from 'path'
+
+const OUTDIR = 'outputs/llm-sim-integration'
+const SNAP_DIR = path.join(OUTDIR, 'snapshots')
+const ADJ_DIR = path.join(OUTDIR, 'adjusted')
+const APPLY_DIR = path.join(OUTDIR, 'apply-scripts')
+const RESULTS_FILE = path.join(OUTDIR, 'results.json')
+
+function seedFromString(s){
+  let h=0; for(let i=0;i<s.length;i++) h = (h*31 + s.charCodeAt(i)) >>> 0; return h
+}
+
+function deterministicBaseline(projectId){
+  const seed = seedFromString(projectId)
+  return 0.65 + (seed % 200)/1000 // 0.65 - 0.85
+}
+
+async function ensure(){
+  await fs.mkdir(SNAP_DIR, { recursive: true })
+  await fs.mkdir(ADJ_DIR, { recursive: true })
+  await fs.mkdir(APPLY_DIR, { recursive: true })
+}
+
+async function main(){
+  await ensure()
+
+  // gather project IDs from local sources: config/projects.json, outputs/assessments, or /tmp prompts
+  let projectIds = new Set()
+
+  // 1) config/projects.json (if present)
+  try{
+    const cfg = JSON.parse(await fs.readFile('config/projects.json','utf8'))
+    if(Array.isArray(cfg.projects)) cfg.projects.forEach(p=>p.id && projectIds.add(p.id))
+    else if(Array.isArray(cfg)) cfg.forEach(p=>p.id && projectIds.add(p.id))
+  }catch(e){}
+
+  // 2) outputs/assessments folder names (pattern: ei_<id>_timestamp)
+  try{
+    const asses = await fs.readdir('outputs/assessments')
+    for(const name of asses){
+      const m = name.match(/^(ei_[a-f0-9]+)|^(\w+)/)
+      if(m){ projectIds.add(m[1] || m[2]) }
+    }
+  }catch(e){}
+
+  // 3) /tmp prompts
+  try{
+    const files = (await fs.readdir('/tmp')).filter(f=>f.startsWith('prompts-') && f.endsWith('.json'))
+    for(const f of files){ const m = f.match(/^prompts-(.+?)-/) || []; if(m[1]) projectIds.add(m[1]) }
+  }catch(e){}
+
+  if(projectIds.size===0){
+    console.error('No local projects found (checked config/projects.json, outputs/assessments, and /tmp).')
+    process.exit(1)
+  }
+
+  const results = []
+
+  for(const projectId of Array.from(projectIds)){
+    try{
+      // snapshot current settings (simulation)
+      const snapshot = { projectId, timestamp: new Date().toISOString(), settings: { keras: { trainingCycles: 20, learningRate: 0.01 } } }
+      const snapPath = path.join(SNAP_DIR, projectId + '.json')
+      await fs.writeFile(snapPath, JSON.stringify(snapshot, null, 2), 'utf8')
+
+      // create adjusted settings (small change)
+      const adjusted = JSON.parse(JSON.stringify(snapshot))
+      adjusted.timestamp = new Date().toISOString()
+      adjusted.settings.keras.trainingCycles = snapshot.settings.keras.trainingCycles + 10
+      adjusted.settings.keras.learningRate = +(snapshot.settings.keras.learningRate * 0.5).toFixed(6)
+      const adjPath = path.join(ADJ_DIR, projectId + '.json')
+      await fs.writeFile(adjPath, JSON.stringify(adjusted, null, 2), 'utf8')
+
+      // write an apply script that would perform the change
+      const applyScript = `#!/usr/bin/env bash
+set -euo pipefail
+echo "[SIM] Applying adjusted settings for project ${projectId}"
+echo "Would set trainingCycles=${adjusted.settings.keras.trainingCycles} learningRate=${adjusted.settings.keras.learningRate}"
+`
+      const applyPath = path.join(APPLY_DIR, projectId + '.sh')
+      await fs.writeFile(applyPath, applyScript, 'utf8')
+      await fs.chmod(applyPath, 0o750)
+
+      // simulate running a test/training and record metrics (deterministic)
+      const baseline = +deterministicBaseline(projectId).toFixed(4)
+      // improvement depends on change magnitude; small deterministic delta
+      const delta = 0.01 + ((seedFromString(projectId) % 20)/1000)
+      const newAcc = +(Math.min(0.9999, baseline + delta)).toFixed(4)
+
+      const record = {
+        projectId,
+        snapshot: snapPath,
+        adjusted: adjPath,
+        applyScript: applyPath,
+        metrics: {
+          before: { accuracy: baseline },
+          after: { accuracy: newAcc },
+        },
+        timestamp: new Date().toISOString()
+      }
+      results.push(record)
+
+      // restore (in simulation, just copy snapshot to restored file)
+      const restoredPath = path.join(OUTDIR, 'restored', projectId + '.json')
+      await fs.mkdir(path.dirname(restoredPath), { recursive: true })
+      await fs.writeFile(restoredPath, JSON.stringify(snapshot, null, 2), 'utf8')
+
+      console.log(`Project ${projectId}: baseline=${baseline} -> after=${newAcc}`)
+    }catch(err){
+      console.error('Error for project', projectId, err)
+    }
+  }
+
+  await fs.writeFile(RESULTS_FILE, JSON.stringify(results, null, 2), 'utf8')
+  console.log('Integration simulation complete. Results:', RESULTS_FILE)
+}
+
+main().catch(err=>{ console.error(err); process.exit(1) })

package/scripts/llm-runner-sim.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+import fs from 'fs/promises'
+import path from 'path'
+
+const OUTDIR = 'outputs/llm-responses'
+const APPLY_DIR = 'outputs/apply-commands'
+
+async function main(){
+  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 to simulate')
+    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} }
+
+      // derive projectId from filename: prompts-<projectId>-<goal>.json
+      const m = f.match(/^prompts-(.+?)-/) || []
+      const projectId = m[1] || 'unknown'
+
+      const simulated = {
+        simulated: true,
+        projectId,
+        promptSnippet: (parsed.prompt||'').slice(0,200),
+        recommendation: 'Adjust Keras block parameters to increase trainingCycles and reduce learningRate',
+      }
+
+      const completionText = `SIMULATED LLM RESPONSE\nRecommendation: ${simulated.recommendation}\n\napply_cli: \`npm run cli -- train-model-keras --api-key $EI_API_KEY --params '{"projectId":"${projectId}","learnId":"<learnId>","trainingCycles":50,"learningRate":0.005}'\`\n`
+
+      const outPath = path.join(OUTDIR, f + '.response.txt')
+      await fs.writeFile(outPath, completionText, 'utf8')
+
+      const applyPath = path.join(APPLY_DIR, f + '.sh')
+      const script = '#!/usr/bin/env bash\nset -euo pipefail\n\n# Simulated apply script from LLM\n' + `echo "Would run: npm run cli -- train-model-keras --api-key $EI_API_KEY --params '{\\"projectId\\":\\"${projectId}\\",\\"learnId\\":\\"<learnId>\\",\\"trainingCycles\\":50,\\"learningRate\\":0.005}'"\n`
+      await fs.writeFile(applyPath, script, 'utf8')
+      await fs.chmod(applyPath, 0o750)
+
+      console.log('Simulated response saved to', outPath)
+      console.log('Simulated apply script saved to', applyPath)
+    }catch(err){
+      console.error('Error simulating for', f, err)
+    }
+  }
+}
+
+main().catch(err=>{ console.error(err); process.exit(1) })