ei-agentic-claude 1.0.0

package/src/postman/edge-impulse/training/start-training/client.ts

@@ -0,0 +1,47 @@
+/**
+ * Generated by Postman Code
+ * Collection: Edge Impulse API
+ * Request: Training > Start Training
+ */
+import type { StartTrainingRequest, StartTrainingResponse, EdgeImpulseError } from "../../shared/types";
+
+
+/**
+ * Start model training for an Edge Impulse project.
+ * @param apiKey - Edge Impulse API key
+ * @param req - Start training request
+ * @returns Training job info
+ */
+export async function startTraining(apiKey: string, req: StartTrainingRequest): Promise<StartTrainingResponse> {
+  const url = `https://studio.edgeimpulse.com/v1/api/${req.projectId}/jobs/train/keras/${req.learnId}`;
+  // Extract only training parameters for the body
+  const { projectId, learnId, ...body } = req;
+  if (!body.mode) body.mode = 'visual';
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "x-api-key": apiKey,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+  if (response.ok) {
+    return (await response.json()) as StartTrainingResponse;
+  }
+  // Print full error response for debugging
+  const errorText = await response.text();
+  const errorInfo = {
+    status: response.status,
+    statusText: response.statusText,
+    headers: Object.fromEntries(response.headers.entries()),
+    body: errorText
+  };
+  console.error("Edge Impulse API error response:", JSON.stringify(errorInfo, null, 2));
+  try {
+    const error = JSON.parse(errorText) as EdgeImpulseError;
+    throw new Error(`Edge Impulse API error: ${error.message}`);
+  } catch {
+    throw new Error(`Edge Impulse API error: ${errorText}`);
+  }
+}
+

package/src/postman/edge-impulse/training/start-training/evaluate.ts

@@ -0,0 +1,32 @@
+/**
+ * Fetch evaluation metrics for a trained Keras block in Edge Impulse.
+ * @param apiKey - Edge Impulse API key
+ * @param projectId - Project ID
+ * @param learnId - Learn (block) ID
+ * @returns Model evaluation metrics and configuration
+ */
+export 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) {
+    return await response.json();
+  }
+  // Print full error details for debugging
+  const errorText = await response.text();
+  const errorInfo = {
+    status: response.status,
+    statusText: response.statusText,
+    headers: Object.fromEntries(response.headers.entries()),
+    body: errorText
+  };
+  console.error("Edge Impulse API evaluation error response:", JSON.stringify(errorInfo, null, 2));
+  if (response.status === 404) {
+    throw new Error(`Evaluation not available via API (404). Please check the Edge Impulse dashboard for results.`);
+  }
+  throw new Error(`Failed to fetch Keras block evaluation: ${response.status}`);
+}

package/src/postman/edge-impulse/training/start-training/status.ts

@@ -0,0 +1,20 @@
+/**
+ * Get the status of a training job for an Edge Impulse project.
+ * @param apiKey - Edge Impulse API key
+ * @param projectId - Project ID
+ * @param jobId - Training job ID
+ * @returns Job status and result
+ */
+export async function getTrainingJobStatus(apiKey: string, projectId: string, jobId: string) {
+  const url = `https://studio.edgeimpulse.com/v1/api/${projectId}/jobs/${jobId}`;
+  const response = await fetch(url, {
+    headers: {
+      "x-api-key": apiKey,
+      "Content-Type": "application/json"
+    }
+  });
+  if (response.ok) {
+    return await response.json();
+  }
+  throw new Error(`Failed to fetch job status: ${response.status}`);
+}

package/src/register-generated-commands.ts

@@ -0,0 +1,47 @@
+// Auto-import and register all CLI commands from generated/cli-commands
+import { Command } from "commander";
+
+import fs from "fs";
+import path from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+import { createRequire } from "module";
+import crypto from "crypto";
+
+export async function registerGeneratedCommands(program: Command) {
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = path.dirname(__filename);
+  const commandsDir = path.join(__dirname, "postman/edge-impulse/generated/cli-commands");
+  // Pick up both .ts (dev) and .js (dist) generated command files.
+  const files = fs.readdirSync(commandsDir).filter(f => f.endsWith('.js') || f.endsWith('.ts'));
+
+  // Load integrity hashes if available
+  const integrityPath = path.join(commandsDir, 'integrity.json');
+  let expectedHashes: Record<string, string> = {};
+  if (fs.existsSync(integrityPath)) {
+    expectedHashes = JSON.parse(fs.readFileSync(integrityPath, 'utf-8'));
+  }
+
+  for (const file of files) {
+    const full = path.join(commandsDir, file);
+
+    // Verify file integrity if hash is available
+    if (expectedHashes[file]) {
+      const actualHash = calculateSHA256(full);
+      if (actualHash !== expectedHashes[file]) {
+        throw new Error(`Integrity check failed for ${file}. File may be corrupted or tampered with.`);
+      }
+    }
+
+    // Use dynamic import so ts-node ESM or Node ESM can load the module correctly.
+    const mod = await import(pathToFileURL(full).href);
+    const fn = Object.values(mod).find(v => typeof v === 'function');
+    if (fn) fn(program);
+  }
+}
+
+function calculateSHA256(filePath: string): string {
+  const fileBuffer = fs.readFileSync(filePath);
+  const hashSum = crypto.createHash('sha256');
+  hashSum.update(fileBuffer); // hash actual file contents
+  return hashSum.digest('hex');
+}

package/test/api-coverage.spec.ts

@@ -0,0 +1,177 @@
+import { describe, it, expect } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const apiDir = path.resolve(__dirname, '../src/postman/edge-impulse/generated');
+
+describe('API Coverage Tests', () => {
+  const apiFiles = fs.readdirSync(apiDir)
+    .filter(f => f.endsWith('.ts') && !f.includes('cli-commands'));
+
+  it('should have substantial API coverage', () => {
+    expect(apiFiles.length).toBeGreaterThan(300);
+  });
+
+  it('all API modules should be importable', async () => {
+    const importPromises = apiFiles.map(async (file) => {
+      const filePath = path.join(apiDir, file);
+      const module = await import(pathToFileURL(filePath).href);
+      return { file, module };
+    });
+
+    const results = await Promise.all(importPromises);
+
+    // All modules should have been imported successfully
+    expect(results).toHaveLength(apiFiles.length);
+
+    // Each module should export at least one function
+    for (const { file, module } of results) {
+      const exportedFunctions = Object.values(module).filter(v => typeof v === 'function');
+      expect(exportedFunctions.length).toBeGreaterThan(0);
+    }
+  });
+
+  it('API functions should have correct signatures', async () => {
+    // Test a representative sample of API functions
+    const testFiles = [
+      'get_projects.ts',
+      'train_model_keras.ts',
+      'optimize_model.ts',
+      'retrain.ts',
+      'get_job_status.ts',
+      'get_current_user.ts',
+      'create_new_project.ts',
+      'add_api_key.ts'
+    ];
+
+    for (const file of testFiles) {
+      if (apiFiles.includes(file)) {
+        const filePath = path.join(apiDir, file);
+        const module = await import(pathToFileURL(filePath).href);
+
+        // Find the main exported function (usually the first async function)
+        const apiFunction = Object.values(module).find(v =>
+          typeof v === 'function' && v.constructor.name === 'AsyncFunction'
+        ) as Function;
+
+        expect(apiFunction).toBeDefined();
+        expect(apiFunction.length).toBe(2); // Should take 2 parameters: params and apiKey
+      }
+    }
+  });
+
+  it('API functions should validate required parameters', async () => {
+    // Test functions that require specific parameters
+    const testCases = [
+      {
+        file: 'train_model_keras.ts',
+        missingParams: [{}], // Missing projectId and learnId
+        expectedError: /Missing required parameters `projectId` and `learnId`/
+      },
+      {
+        file: 'optimize_model.ts',
+        missingParams: [{}], // Missing projectId
+        expectedError: /Missing required parameter `projectId`/
+      },
+      {
+        file: 'retrain.ts',
+        missingParams: [{}], // Missing projectId
+        expectedError: /Missing required parameter `projectId`/
+      }
+    ];
+
+    for (const { file, missingParams, expectedError } of testCases) {
+      if (apiFiles.includes(file)) {
+        const filePath = path.join(apiDir, file);
+        const module = await import(pathToFileURL(filePath).href);
+
+        const apiFunction = Object.values(module).find(v =>
+          typeof v === 'function' && v.constructor.name === 'AsyncFunction'
+        ) as Function;
+
+        for (const params of missingParams) {
+          await expect(apiFunction(params, 'fake-api-key')).rejects.toThrow(expectedError);
+        }
+      }
+    }
+  });
+
+  it('API functions should handle parameter processing correctly', async () => {
+    // Test parameter processing without making actual API calls
+    const testCases = [
+      {
+        file: 'get_projects.ts',
+        params: { organizationId: '123', type: 'classification' },
+        apiKey: 'fake-key'
+      },
+      {
+        file: 'get_current_user.ts',
+        params: {},
+        apiKey: 'fake-key'
+      }
+    ];
+
+    for (const { file, params, apiKey } of testCases) {
+      if (apiFiles.includes(file)) {
+        const filePath = path.join(apiDir, file);
+        const module = await import(pathToFileURL(filePath).href);
+
+        const apiFunction = Object.values(module).find(v =>
+          typeof v === 'function' && v.constructor.name === 'AsyncFunction'
+        ) as Function;
+
+        // Should not throw during parameter processing (will fail at fetch)
+        // This tests that parameter validation and URL construction works
+        try {
+          await apiFunction(params, apiKey);
+        } catch (error: any) {
+          // Should fail at network level, not parameter validation
+          expect(error.message).not.toMatch(/Missing required parameters/);
+          expect(error.message).not.toMatch(/undefined/);
+        }
+      }
+    }
+  });
+
+  it('should cover all major API categories', () => {
+    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')),
+      data: apiFiles.filter(f => f.includes('data') || f.includes('sample')),
+      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')),
+      admin: apiFiles.filter(f => f.includes('admin') || f.includes('white_label'))
+    };
+
+    // Each category should have multiple APIs
+    expect(categories.projects.length).toBeGreaterThan(10);
+    expect(categories.training.length).toBeGreaterThan(5);
+    expect(categories.data.length).toBeGreaterThan(20);
+    expect(categories.jobs.length).toBeGreaterThan(5);
+  });
+
+  it('API functions should have JSDoc comments', async () => {
+    // Test that API functions have proper documentation
+    const testFiles = ['get_projects.ts', 'train_model_keras.ts', 'get_job_status.ts'];
+
+    for (const file of testFiles) {
+      if (apiFiles.includes(file)) {
+        const filePath = path.join(apiDir, file);
+        const content = fs.readFileSync(filePath, 'utf8');
+
+        // Should have JSDoc comment with Method and URL
+        expect(content).toMatch(/\*\s*Method:/);
+        expect(content).toMatch(/\*\s*URL:/);
+        expect(content).toMatch(/export async function/);
+      }
+    }
+  });
+});

package/test/cli.spec.ts

@@ -0,0 +1,29 @@
+import { describe, it, expect } from 'vitest';
+import { execFileSync } from 'child_process';
+import path from 'path';
+
+const launcher = path.resolve(__dirname, '..', 'launch-cli.mjs');
+
+function run(args: string[]) {
+  return execFileSync(process.execPath, [launcher, ...args], { encoding: 'utf8' });
+}
+
+describe('CLI smoke', () => {
+  it('shows top-level help', () => {
+    const out = run(['--help']);
+    expect(out).toContain('train-model-keras');
+    expect(out).toContain('wait-job');
+  });
+
+  it('train-model-keras has help', () => {
+    const out = run(['train-model-keras', '--help']);
+    expect(out).toMatch(/train_model_keras|--projectId/);
+  });
+
+  it('wait-job has help and options', () => {
+    const out = run(['wait-job', '--help']);
+    expect(out).toMatch(/Poll a job until completion/);
+    expect(out).toMatch(/--projectId/);
+    expect(out).toMatch(/--jobId/);
+  });
+});