@testcollab/cli 1.3.0

package/samples/reports/mochawesome.json

@@ -0,0 +1,110 @@
+{
+  "stats": {
+    "suites": 1,
+    "tests": 3,
+    "passes": 1,
+    "pending": 1,
+    "failures": 1,
+    "start": "2026-02-24T00:00:00.000Z",
+    "end": "2026-02-24T00:00:00.620Z",
+    "duration": 620,
+    "testsRegistered": 3,
+    "passPercent": 33.3333,
+    "pendingPercent": 33.3333,
+    "other": 0,
+    "hasOther": false,
+    "skipped": 1,
+    "hasSkipped": true
+  },
+  "results": [
+    {
+      "uuid": "suite-authentication",
+      "title": "Authentication",
+      "fullFile": "",
+      "file": "",
+      "beforeHooks": [],
+      "afterHooks": [],
+      "tests": [
+        {
+          "title": "[TC-1913] should login with valid credentials",
+          "fullTitle": "Authentication.Login [TC-1913] should login with valid credentials",
+          "timedOut": false,
+          "duration": 120,
+          "state": "passed",
+          "speed": "fast",
+          "pass": true,
+          "fail": false,
+          "pending": false,
+          "context": null,
+          "code": "",
+          "err": {},
+          "uuid": "test-auth-pass",
+          "parentUUID": "suite-authentication",
+          "isHook": false,
+          "skipped": false
+        },
+        {
+          "title": "[TC-1914] should reject invalid password",
+          "fullTitle": "Authentication.Login [TC-1914] should reject invalid password",
+          "timedOut": false,
+          "duration": 430,
+          "state": "failed",
+          "speed": "slow",
+          "pass": false,
+          "fail": true,
+          "pending": false,
+          "context": null,
+          "code": "",
+          "err": {
+            "message": "Expected invalid password error",
+            "estack": "AssertionError: expected status 401 but got 200"
+          },
+          "uuid": "test-auth-fail",
+          "parentUUID": "suite-authentication",
+          "isHook": false,
+          "skipped": false
+        },
+        {
+          "title": "[TC-1915] should support SSO login",
+          "fullTitle": "Authentication.Login [TC-1915] should support SSO login",
+          "timedOut": false,
+          "duration": 70,
+          "state": "skipped",
+          "speed": "fast",
+          "pass": false,
+          "fail": false,
+          "pending": true,
+          "context": null,
+          "code": "",
+          "err": {},
+          "uuid": "test-auth-skip",
+          "parentUUID": "suite-authentication",
+          "isHook": false,
+          "skipped": true
+        }
+      ],
+      "suites": [],
+      "passes": [
+        "test-auth-pass"
+      ],
+      "failures": [
+        "test-auth-fail"
+      ],
+      "pending": [
+        "test-auth-skip"
+      ],
+      "skipped": [
+        "test-auth-skip"
+      ],
+      "duration": 620,
+      "root": false,
+      "rootEmpty": false,
+      "_timeout": 0
+    }
+  ],
+  "meta": {
+    "source": "sample",
+    "generatedBy": "testcollab-cli",
+    "generatedAt": "2026-02-24T00:00:00.000Z"
+  }
+}

package/scripts/bump-version.js

@@ -0,0 +1,145 @@
+import { execSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const rootDir = path.resolve(__dirname, '..');
+
+function parseVersion(version) {
+  const cleanVersion = version.split('-')[0];
+  const parts = cleanVersion.split('.').map(Number);
+  if (parts.length !== 3 || parts.some(Number.isNaN)) {
+    throw new Error(`Invalid version format: ${version}`);
+  }
+  return parts;
+}
+
+function compare(v1, v2) {
+  const p1 = parseVersion(v1);
+  const p2 = parseVersion(v2);
+  for (let i = 0; i < 3; i += 1) {
+    if (p1[i] > p2[i]) return 1;
+    if (p1[i] < p2[i]) return -1;
+  }
+  return 0;
+}
+
+function bumpMinor(version) {
+  const [maj, min] = parseVersion(version);
+  return `${maj}.${min + 1}.0`;
+}
+
+function bumpPatch(version) {
+  const [maj, min, pat] = parseVersion(version);
+  return `${maj}.${min}.${pat + 1}`;
+}
+
+function npmView(pkg, token) {
+  if (!token) {
+    try {
+      const v = execSync(`npm view ${pkg} version`, { encoding: 'utf8' }).trim();
+      console.log(`Latest published version for ${pkg}: ${v}`);
+      return v;
+    } catch (error) {
+      console.log(`Could not fetch version from npm for ${pkg} (might not exist yet).`);
+      return undefined;
+    }
+  }
+
+  const tmpRc = path.join(os.tmpdir(), `.npmrc-${Date.now()}-${Math.random()}`);
+  try {
+    fs.writeFileSync(tmpRc, `//registry.npmjs.org/:_authToken=${token}\n`, 'utf8');
+    const v = execSync(`npm view ${pkg} version --userconfig ${tmpRc}`, { encoding: 'utf8' }).trim();
+    console.log(`Latest published version for ${pkg} (auth): ${v}`);
+    return v;
+  } catch (error) {
+    console.log(`Could not fetch version from npm for ${pkg} with auth (might not exist yet).`);
+    return undefined;
+  } finally {
+    try {
+      fs.unlinkSync(tmpRc);
+    } catch (_) {
+      // ignore cleanup errors
+    }
+  }
+}
+
+function readJson(jsonPath) {
+  return JSON.parse(fs.readFileSync(jsonPath, 'utf8'));
+}
+
+function writeJson(jsonPath, data) {
+  fs.writeFileSync(jsonPath, `${JSON.stringify(data, null, 2)}\n`);
+}
+
+function updateLockFile(lockPath, newVersion) {
+  if (!fs.existsSync(lockPath)) return;
+
+  const lockJson = readJson(lockPath);
+
+  if (lockJson.version) {
+    lockJson.version = newVersion;
+  }
+
+  if (lockJson.packages && lockJson.packages['']) {
+    lockJson.packages[''].version = newVersion;
+  }
+
+  writeJson(lockPath, lockJson);
+  console.log(`package-lock.json updated to ${newVersion}`);
+}
+
+try {
+  const packageJsonPath = path.join(rootDir, 'package.json');
+  const lockPath = path.join(rootDir, 'package-lock.json');
+
+  const packageJson = readJson(packageJsonPath);
+  const packageName = packageJson.name;
+  const localVersion = packageJson.version;
+  console.log(`Local package.json version: ${localVersion}`);
+
+  const publishedVersion = npmView(packageName, process.env.NPM_TOKEN);
+  const knownPublished = [publishedVersion].filter(Boolean);
+
+  let baseVersion = localVersion;
+  for (const version of knownPublished) {
+    if (compare(version, baseVersion) === 1) {
+      baseVersion = version;
+    }
+  }
+
+  let newVersion;
+  const localIsHighest = knownPublished.every(
+    (version) => !version || compare(localVersion, version) === 1,
+  );
+
+  if (localIsHighest) {
+    newVersion = localVersion;
+    console.log(`Local version (${localVersion}) is highest; keeping it.`);
+  } else {
+    newVersion = bumpMinor(baseVersion);
+    console.log(`Auto-incrementing minor from ${baseVersion} to ${newVersion}`);
+  }
+
+  const publishedSet = new Set(knownPublished);
+  while (publishedSet.has(newVersion)) {
+    const bumped = bumpPatch(newVersion);
+    console.log(`Version ${newVersion} already published; bumping patch to ${bumped}`);
+    newVersion = bumped;
+  }
+
+  if (newVersion !== localVersion) {
+    packageJson.version = newVersion;
+    writeJson(packageJsonPath, packageJson);
+    console.log(`package.json updated to ${newVersion}`);
+  } else {
+    console.log('package.json version already at desired value; no change needed.');
+  }
+
+  updateLockFile(lockPath, newVersion);
+} catch (error) {
+  console.error('Error bumping version:', error);
+  process.exit(1);
+}

package/src/ai/discovery.js

@@ -0,0 +1,123 @@
+import path from 'path';
+
+const DISCOVERY_SCHEMA = {
+  type: 'object',
+  additionalProperties: false,
+  properties: {
+    families: {
+      type: 'array',
+      items: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          name: { type: 'string' },
+          kind: { type: 'string', enum: ['backend', 'ui', 'cli', 'job', 'lib'] },
+          paths: { type: 'array', items: { type: 'string' } },
+          priority: { type: 'string' },
+          output_root: { type: 'string' },
+        },
+        required: ['name', 'paths'],
+      },
+    },
+    targets: {
+      type: 'array',
+      items: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          id: { type: 'string' },
+          family: { type: 'string' },
+          type: { type: 'string' },
+          entry: { type: 'array', items: { type: 'string' } },
+          priority: { type: 'string' },
+          output_path: { type: 'string' },
+        },
+        required: ['id', 'family', 'entry'],
+      },
+    },
+    notes: {
+      type: 'array',
+      items: { type: 'string' },
+    },
+  },
+  required: ['families', 'targets'],
+};
+
+export function buildDiscoveryPrompt(summaries, snippetLines) {
+  const header = [
+    'You are specgen. Infer target families and targets from the supplied source files.',
+    '',
+    'Definitions:',
+    '- Target family: domain bucket with name, kind (backend/ui/cli/job/lib), and paths (globs/dirs).',
+    '- Target: concrete unit with id, family, type (api_controller/service/ui_component/page/job/cli_command/module), and entry file(s).',
+    '',
+    'Rules:',
+    '- Use directory names for stable ids; prefer one target per route/controller/component/job/cli.',
+    '- Skip vendor/build/test/config files.',
+    '- Return JSON matching the schema.',
+    '',
+    'Files:',
+  ];
+  const body = summaries.map((s, idx) => {
+    const trimmed = (s.snippet || '').split('\n').slice(0, snippetLines).join('\n');
+    return `#${idx + 1} ${s.rel}\n---\n${trimmed}\n---`;
+  });
+  return [...header, ...body].join('\n');
+}
+
+export async function aiDiscoverTargets({ provider, anthropic, gemini, model, summaries, outRoot, snippetLines }) {
+  const prompt = buildDiscoveryPrompt(summaries, snippetLines);
+  if (provider === 'anthropic') {
+    const resp = await anthropic.messages.create({
+      model,
+      max_tokens: 4000,
+      temperature: 0.1,
+      response_format: { type: 'json_schema', json_schema: { name: 'DiscoverySpec', schema: DISCOVERY_SCHEMA } },
+      messages: [
+        {
+          role: 'user',
+          content: [{ type: 'text', text: prompt }],
+        },
+      ],
+    });
+    const text = resp?.content?.[0]?.text;
+    if (!text) return null;
+    return normalizeDiscovery(JSON.parse(text), outRoot);
+  }
+
+  if (provider === 'gemini') {
+    const modelHandle = gemini.getGenerativeModel({
+      model,
+      generationConfig: {
+        responseMimeType: 'application/json',
+        responseSchema: DISCOVERY_SCHEMA,
+      },
+    });
+    const result = await modelHandle.generateContent([{ text: prompt }]);
+    const text = result?.response?.text();
+    if (!text) return null;
+    return normalizeDiscovery(JSON.parse(text), outRoot);
+  }
+
+  throw new Error(`Unsupported provider for discovery: ${provider}`);
+}
+
+function normalizeDiscovery(parsed, outRoot) {
+  const normalizedFamilies = (parsed.families || []).map((f) => ({
+    ...f,
+    output_root: f.output_root || path.join(outRoot, f.name),
+  }));
+  const targets = (parsed.targets || []).map((t) => ({
+    ...t,
+    output_path:
+      t.output_path ||
+      path.join(
+        normalizedFamilies.find((f) => f.name === t.family)?.output_root || outRoot,
+        `${t.id}.feature`,
+      ),
+  }));
+  if (parsed.notes?.length) {
+    console.log(`ℹ️  AI discovery notes: ${parsed.notes.join(' | ')}`);
+  }
+  return { families: normalizedFamilies, targets };
+}

package/src/commands/createTestPlan.js

@@ -0,0 +1,259 @@
+/**
+ * createTestPlan.js
+ *
+ * Creates a Test Plan in TestCollab, adds CI-tagged test cases,
+ * and assigns the plan to a user.
+ *
+ * Options:
+ * - --api-key        API token
+ * - --project        Project ID
+ * - --ci-tag-id      Tag ID to select test cases
+ * - --assignee-id    User ID to assign the plan
+ * - --api-url        (defaults to https://api.testcollab.io)
+ */
+
+import fs from 'fs';
+import {
+  TestPlansApi,
+  TestPlanTestCasesApi,
+  TestPlansAssignmentApi,
+  Configuration,
+  ProjectsApi,
+  UsersApi,
+  TestCasesApi,
+  ProjectUsersApi
+} from 'testcollab-sdk';
+
+function getDate() {
+  const now = new Date();
+  const dd = String(now.getDate()).padStart(2, '0');
+  const mm = String(now.getMonth() + 1).padStart(2, '0');
+  const yyyy = now.getFullYear();
+  const hh = String(now.getHours()).padStart(2, '0');
+  const min = String(now.getMinutes()).padStart(2, '0');
+  return `${dd}-${mm}-${yyyy} ${hh}:${min}`;
+}
+
+export async function createTestPlan(options) {
+  const {
+    project,
+    ciTagId,
+    assigneeId,
+    apiUrl
+  } = options;
+
+  // Resolve API key: --api-key flag takes precedence, then TESTCOLLAB_TOKEN env var
+  const apiKey = options.apiKey || process.env.TESTCOLLAB_TOKEN;
+
+  // Normalize/Default API base URL
+  const effectiveApiUrl = (apiUrl && String(apiUrl).trim())
+    ? String(apiUrl).trim().replace(/\/+$/, '')
+    : 'https://api.testcollab.io';
+
+  // Validate required inputs
+  if (!apiKey) {
+    console.error('❌ Error: No API key provided');
+    console.error('   Pass --api-key <key> or set the TESTCOLLAB_TOKEN environment variable.');
+    process.exit(1);
+  }
+  if (!project) {
+    console.error('❌ Error: --project is required');
+    process.exit(1);
+  }
+  if (!ciTagId) {
+    console.error('❌ Error: --ci-tag-id is required');
+    process.exit(1);
+  }
+  if (!assigneeId) {
+    console.error('❌ Error: --assignee-id is required');
+    process.exit(1);
+  }
+
+  const parsedProjectId = Number(project);
+  const parsedTagId = Number(ciTagId);
+  const parsedAssigneeId = Number(assigneeId);
+
+  if (Number.isNaN(parsedProjectId)) {
+    console.error('❌ Error: --project must be a number');
+    process.exit(1);
+  }
+  if (Number.isNaN(parsedTagId)) {
+    console.error('❌ Error: --ci-tag-id must be a number');
+    process.exit(1);
+  }
+  if (Number.isNaN(parsedAssigneeId)) {
+    console.error('❌ Error: --assignee-id must be a number');
+    process.exit(1);
+  }
+
+  // Configure SDK with token and base URL via fetchApi hook
+  const config = new Configuration({
+    basePath: effectiveApiUrl,
+    fetchApi: (url, opts) => {
+      const separator = url.includes('?') ? '&' : '?';
+      const urlWithToken = `${url}${separator}token=${apiKey}`;
+      return fetch(urlWithToken, opts);
+    }
+  });
+
+  const projectsApi = new ProjectsApi(config);
+  const usersApi = new UsersApi(config);
+  const tcApi = new TestCasesApi(config);
+  const projectUsersApi = new ProjectUsersApi(config);
+  const testPlansApi = new TestPlansApi(config);
+  const testPlanCases = new TestPlanTestCasesApi(config);
+  const testPlanAssignment = new TestPlansAssignmentApi(config);
+
+  // Ensure tmp directory exists and remove old id file if present
+  try {
+    if (!fs.existsSync('tmp')) {
+      fs.mkdirSync('tmp', { recursive: true });
+    }
+    if (fs.existsSync('tmp/tc_test_plan')) {
+      fs.unlinkSync('tmp/tc_test_plan');
+    }
+  } catch (e) {
+    // Non-fatal; continue
+  }
+
+  console.log('validating project and other details...');
+  try {
+    const projectResponse = await projectsApi.getProjects({
+      filter: JSON.stringify({
+        id: parsedProjectId
+      })
+    });
+    if(!projectResponse || !projectResponse.length) {
+      console.error('❌ Error: Project not found. Ensure you have access to this project.');
+      process.exit(1);
+    }
+  } catch (e) {
+    console.error('❌ Error: Failed to validate project. Ensure the project ID is correct and you have access.');
+    // console.error(e);
+    process.exit(1);
+  }
+
+  try {
+    const tagResponse = await tcApi.getTestCasesTags({
+      project: parsedProjectId,
+      filter: JSON.stringify({
+        id: parsedTagId
+      })
+    });
+    if(!tagResponse || !tagResponse.length || !tagResponse[0].id || tagResponse[0].id !== parsedTagId) {
+      console.error('❌ Error: Tag not found or tag does not belong to the project');
+      process.exit(1);
+    }
+  } catch (e) {
+    console.error('❌ Error: Invalid tag ID or tag does not belong to the project');
+    // console.error(e);
+    process.exit(1);
+  }
+
+  try{
+    let projectUsers = await projectUsersApi.getProjectUsers({
+      project: parsedProjectId,
+      limit: -1
+    });
+    if(!projectUsers || !projectUsers.length) {
+      console.error('❌ Error: Invalid assignee or assignee does not have access to the project');
+      process.exit(1);
+    }
+    let assigneeFound = false;
+    for(let i = 0; i < projectUsers.length; i++) {
+      if(projectUsers[i].user.id === parsedAssigneeId) {
+        assigneeFound = true;
+        break;
+      }
+    }
+    if(!assigneeFound) {
+      console.error('❌ Error: Invalid assignee or assignee does not have access to the project');
+      process.exit(1);
+    }
+  }catch (e) {
+    console.error('❌ Error: Invalid assignee or assignee does not have access to the project');
+    // console.error(e);
+    process.exit(1);
+  }
+
+  try {
+    console.log('Step 1: Creating a new test plan...');
+    const createResponse = await testPlansApi.addTestPlan({
+      testPlanPayload: {
+        project: parsedProjectId,
+        title: `CI Test: ${getDate()}`,
+        description: 'This is a test plan created using the Node.js SDK',
+        status: 1,
+        priority: 1,
+        testPlanFolder: null,
+        customFields: []
+      }
+    });
+
+    const testPlanId = createResponse.id;
+    console.log(`Test Plan ID: ${testPlanId}`);
+
+    console.log('Step 2: Adding test cases (matching CI tag) to the test plan...');
+    let tptcAddResult = await testPlanCases.bulkAddTestPlanTestCases({
+      testPlanTestCaseBulkAddPayload: {
+        testplan: testPlanId,
+        testCaseCollection: {
+          testCases: [],
+          selector: [
+            {
+              field: 'tags',
+              operator: 'jsonstring_2',
+              value: `{"filter":[[${parsedTagId}]],"type":"equals","filterType":"number"}`
+            }
+          ]
+        }
+      }
+    });
+    if(tptcAddResult && tptcAddResult.status === false) {
+      console.error('❌ Error: Failed to add test cases to the test plan');
+      console.error(tptcAddResult);
+      process.exit(1);
+    }
+
+    console.log('Step 3: Assigning the test plan to a user...');
+    const assignmentResponse = await testPlanAssignment.assignTestPlan({
+      project: parsedProjectId,
+      testplan: testPlanId,
+      testPlanAssignmentPayload: {
+        executor: 'team',
+        assignmentCriteria: 'testCase',
+        assignmentMethod: 'automatic',
+        assignment: {
+          user: [parsedAssigneeId],
+          testCases: { testCases: [], selector: [] },
+          configuration: null
+        },
+        project: parsedProjectId,
+        testplan: testPlanId
+      }
+    });
+
+    console.log(assignmentResponse);
+
+    // Persist test plan id
+    fs.writeFileSync('tmp/tc_test_plan', `TESTCOLLAB_TEST_PLAN_ID=${testPlanId}`);
+    console.log('✅ Test plan created and assigned successfully.');
+  } catch (error) {
+    // console.error("ERROR:", error);
+    // Improve error visibility if error is a Response-like object
+    if (error && typeof error === 'object' && 'status' in error && 'text' in error) {
+      try {
+        const bodyText = await error.text();
+        console.error(`❌ Error: HTTP ${error.status} ${error.statusText || ''} - ${bodyText}`);
+      } catch {
+        console.error(`❌ Error: HTTP ${error.status} ${error.statusText || ''}`);
+      }
+    } else {
+      const message = error?.message || String(error);
+      console.error(`❌ Error: ${message}`);
+    }
+    process.exit(1);
+  }
+}
+
+