codequiry-cli 1.0.0 → 2.0.1

package/src/commands/create.js

@@ -0,0 +1,86 @@
+'use strict';
+
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const ora = require('ora');
+const { requireAuth } = require('../utils/errors');
+const { getLanguages, getTestTypes, createCheck } = require('../api/endpoints');
+
+async function createCommand(options) {
+  requireAuth();
+
+  let name = options.name;
+  let languageId = options.language;
+  let testType = options.testType;
+
+  // Fetch languages and test types
+  const spinner = ora('Loading options...').start();
+  let languages, testTypes;
+
+  try {
+    [languages, testTypes] = await Promise.all([getLanguages(), getTestTypes()]);
+    spinner.stop();
+  } catch (error) {
+    spinner.fail('Failed to load options.');
+    return;
+  }
+
+  const langList = Array.isArray(languages) ? languages : languages?.languages || [];
+  const typeList = Array.isArray(testTypes) ? testTypes : testTypes?.test_types || [];
+
+  // Interactive prompts for missing options
+  const questions = [];
+
+  if (!name) {
+    questions.push({
+      type: 'input',
+      name: 'name',
+      message: 'Check name:',
+      validate: (input) => (input.length > 0 ? true : 'Name is required'),
+    });
+  }
+
+  if (!languageId) {
+    questions.push({
+      type: 'list',
+      name: 'languageId',
+      message: 'Programming language:',
+      choices: langList.map((l) => ({
+        name: l.language || l.name,
+        value: l.id,
+      })),
+    });
+  }
+
+  if (!testType) {
+    questions.push({
+      type: 'list',
+      name: 'testType',
+      message: 'Check engine:',
+      choices: typeList.map((t) => ({
+        name: t.name || t.type,
+        value: t.id,
+      })),
+    });
+  }
+
+  if (questions.length > 0) {
+    const answers = await inquirer.prompt(questions);
+    name = name || answers.name;
+    languageId = languageId || answers.languageId;
+    testType = testType || answers.testType;
+  }
+
+  const createSpinner = ora('Creating check...').start();
+
+  try {
+    const result = await createCheck(name, languageId, testType);
+    // API returns the Assignment object directly
+    createSpinner.succeed(`Check created: ${chalk.cyan(result.name || name)} (ID: ${result.id || 'N/A'})`);
+    return result;
+  } catch (error) {
+    createSpinner.fail('Failed to create check.');
+  }
+}
+
+module.exports = createCommand;

package/src/commands/delete.js

@@ -0,0 +1,72 @@
+'use strict';
+
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const ora = require('ora');
+const { requireAuth } = require('../utils/errors');
+const { listChecks, deleteCheck } = require('../api/endpoints');
+
+async function deleteCommand(options) {
+  requireAuth();
+
+  let checkId = options.check;
+
+  if (!checkId) {
+    const spinner = ora('Fetching checks...').start();
+    let checks;
+    try {
+      const data = await listChecks();
+      checks = Array.isArray(data) ? data : data?.checks || [];
+      spinner.stop();
+    } catch (error) {
+      spinner.fail('Failed to fetch checks.');
+      return;
+    }
+
+    if (checks.length === 0) {
+      console.log(chalk.yellow('\n⚠ No checks found.\n'));
+      return;
+    }
+
+    const { selectedCheck } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'selectedCheck',
+        message: 'Select a check to delete:',
+        choices: checks.map((c) => ({
+          name: `${c.id} - ${c.name}`,
+          value: c.id,
+        })),
+      },
+    ]);
+    checkId = selectedCheck;
+  }
+
+  // Confirm deletion
+  if (!options.force) {
+    const { confirm } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirm',
+        message: `Are you sure you want to delete check ${checkId}?`,
+        default: false,
+      },
+    ]);
+
+    if (!confirm) {
+      console.log(chalk.dim('\n  Cancelled.\n'));
+      return;
+    }
+  }
+
+  const spinner = ora('Deleting check...').start();
+
+  try {
+    await deleteCheck(checkId);
+    spinner.succeed(`Check ${chalk.cyan(checkId)} deleted.`);
+  } catch (error) {
+    spinner.fail('Failed to delete check.');
+  }
+}
+
+module.exports = deleteCommand;

package/src/commands/results.js

@@ -0,0 +1,118 @@
+'use strict';
+
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const ora = require('ora');
+const open = require('open');
+const { requireAuth } = require('../utils/errors');
+const { listChecks, getOverview, getResults } = require('../api/endpoints');
+const { overviewTable, resultsDetailTable } = require('../utils/display');
+
+async function resultsCommand(options) {
+  requireAuth();
+
+  let checkId = options.check;
+
+  if (!checkId) {
+    const spinner = ora('Fetching checks...').start();
+    let checks;
+    try {
+      const data = await listChecks();
+      checks = Array.isArray(data) ? data : data?.checks || [];
+      spinner.stop();
+    } catch (error) {
+      spinner.fail('Failed to fetch checks.');
+      return;
+    }
+
+    // Filter to completed checks
+    const completed = checks.filter(
+      (c) => c.status_id === 4 || c.assignmentstatuses?.status === 'Completed'
+    );
+
+    if (completed.length === 0) {
+      console.log(chalk.yellow('\n⚠ No completed checks found.\n'));
+      return;
+    }
+
+    const { selectedCheck } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'selectedCheck',
+        message: 'Select a check:',
+        choices: completed.map((c) => ({
+          name: `${c.id} - ${c.name}`,
+          value: c.id,
+        })),
+      },
+    ]);
+    checkId = selectedCheck;
+  }
+
+  // Fetch overview
+  const spinner = ora('Fetching results...').start();
+  let overview;
+  try {
+    overview = await getOverview(checkId);
+    spinner.stop();
+  } catch (error) {
+    spinner.fail('Failed to fetch results.');
+    return;
+  }
+
+  console.log(chalk.bold('\n  Results Overview'));
+  overviewTable(overview);
+
+  const submissions = overview?.submissions || overview || [];
+  if (!Array.isArray(submissions) || submissions.length === 0) return;
+
+  // Offer to drill into a submission
+  if (process.stdout.isTTY) {
+    const { action } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'action',
+        message: 'What would you like to do?',
+        choices: [
+          { name: 'View submission details', value: 'detail' },
+          { name: 'Open in browser', value: 'browser' },
+          { name: 'Exit', value: 'exit' },
+        ],
+      },
+    ]);
+
+    if (action === 'detail') {
+      const { submissionId } = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'submissionId',
+          message: 'Select a submission:',
+          choices: submissions.map((s) => ({
+            name: `${s.id} - ${s.filename || 'unknown'}`,
+            value: s.id,
+          })),
+        },
+      ]);
+
+      const detailSpinner = ora('Fetching details...').start();
+      try {
+        const details = await getResults(checkId, submissionId);
+        detailSpinner.stop();
+        resultsDetailTable(details);
+      } catch (error) {
+        detailSpinner.fail('Failed to fetch details.');
+      }
+    } else if (action === 'browser') {
+      const url = overview?.overviewURL || `https://codequiry.com/results/${checkId}`;
+      await open(url);
+      console.log(chalk.dim('  Opened in browser.\n'));
+    }
+  }
+
+  // Output JSON if requested
+  if (options.output === 'json') {
+    console.log(JSON.stringify(overview, null, 2));
+  }
+}
+
+module.exports = resultsCommand;

package/src/commands/scan.js

@@ -0,0 +1,189 @@
+'use strict';
+
+const path = require('path');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const ora = require('ora');
+const { requireAuth } = require('../utils/errors');
+const { getLanguages, getTestTypes, createCheck, uploadZip, uploadBatch, startCheck } = require('../api/endpoints');
+const { prepareUploads, cleanupTempFiles } = require('../utils/zipper');
+const { pollUntilComplete } = require('../utils/poller');
+const { overviewTable } = require('../utils/display');
+const { getOverview } = require('../api/endpoints');
+
+async function scanCommand(inputPath, options) {
+  requireAuth();
+
+  const isTTY = process.stdout.isTTY;
+  const isJson = options.output === 'json';
+
+  // 1. Resolve input path
+  if (!inputPath) {
+    if (isTTY) {
+      const { filePath } = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'filePath',
+          message: 'Path to folder to scan:',
+          default: '.',
+          validate: (input) => {
+            const fs = require('fs');
+            return fs.existsSync(path.resolve(input)) ? true : 'Path does not exist';
+          },
+        },
+      ]);
+      inputPath = filePath;
+    } else {
+      inputPath = '.';
+    }
+  }
+
+  const resolvedPath = path.resolve(inputPath);
+
+  // 2. Get language + test type
+  let languageId = options.language;
+  let testType = options.testType;
+  let checkName = options.name || path.basename(resolvedPath);
+
+  if (!languageId || !testType) {
+    const spinner = ora('Loading options...').start();
+    let languages, testTypes;
+    try {
+      [languages, testTypes] = await Promise.all([getLanguages(), getTestTypes()]);
+      spinner.stop();
+    } catch (error) {
+      spinner.fail('Failed to load options.');
+      process.exit(1);
+    }
+
+    const langList = Array.isArray(languages) ? languages : languages?.languages || [];
+    const typeList = Array.isArray(testTypes) ? testTypes : testTypes?.test_types || [];
+
+    if (isTTY) {
+      const answers = await inquirer.prompt([
+        ...(!languageId
+          ? [
+              {
+                type: 'list',
+                name: 'languageId',
+                message: 'Programming language:',
+                choices: langList.map((l) => ({ name: l.language || l.name, value: l.id })),
+              },
+            ]
+          : []),
+        ...(!testType
+          ? [
+              {
+                type: 'list',
+                name: 'testType',
+                message: 'Check engine:',
+                choices: typeList.map((t) => ({ name: t.name || t.type, value: t.id })),
+              },
+            ]
+          : []),
+      ]);
+      languageId = languageId || answers.languageId;
+      testType = testType || answers.testType;
+    } else {
+      // Non-TTY: use defaults
+      languageId = languageId || (langList[0] && langList[0].id);
+      testType = testType || (typeList[0] && typeList[0].id);
+    }
+  }
+
+  // 3. Zip
+  const zipSpinner = ora('Preparing files...').start();
+  let zipFiles;
+  try {
+    zipFiles = await prepareUploads(resolvedPath);
+    zipSpinner.succeed(`Prepared ${zipFiles.length} file(s)`);
+  } catch (error) {
+    zipSpinner.fail('Failed to prepare files: ' + error.message);
+    process.exit(1);
+  }
+
+  // 4. Create check
+  const createSpinner = ora('Creating check...').start();
+  let check;
+  try {
+    const result = await createCheck(checkName, languageId, testType);
+    check = result; // API returns Assignment object directly
+    createSpinner.succeed(`Check created: ${chalk.cyan(check.name || checkName)} (ID: ${check.id})`);
+  } catch (error) {
+    createSpinner.fail('Failed to create check.');
+    cleanupTempFiles(zipFiles);
+    process.exit(1);
+  }
+
+  // 5. Upload
+  const uploadSpinner = ora('Uploading files...').start();
+  try {
+    if (zipFiles.length === 1) {
+      await uploadZip(check.id, zipFiles[0]);
+    } else {
+      for (let i = 0; i < zipFiles.length; i += 50) {
+        const chunk = zipFiles.slice(i, i + 50);
+        await uploadBatch(check.id, chunk);
+        uploadSpinner.text = `Uploading... (${Math.min(i + 50, zipFiles.length)}/${zipFiles.length})`;
+      }
+    }
+    uploadSpinner.succeed(`Uploaded ${zipFiles.length} file(s)`);
+  } catch (error) {
+    uploadSpinner.fail('Upload failed.');
+    cleanupTempFiles(zipFiles);
+    process.exit(1);
+  }
+
+  cleanupTempFiles(zipFiles);
+
+  // 6. Start check
+  const webcheck = options.web ? 1 : 0;
+  const dbcheck = options.db ? 1 : 0;
+
+  const startSpinner = ora('Starting check...').start();
+  try {
+    await startCheck(check.id, webcheck, dbcheck);
+    startSpinner.succeed('Check started!');
+  } catch (error) {
+    startSpinner.fail('Failed to start check.');
+    process.exit(1);
+  }
+
+  // 7. Poll until complete
+  console.log('');
+  const finalStatus = await pollUntilComplete(check.id);
+
+  // 8. Show results
+  if (finalStatus) {
+    try {
+      const overview = await getOverview(check.id);
+
+      if (isJson) {
+        console.log(JSON.stringify(overview, null, 2));
+      } else {
+        console.log(chalk.bold('\n  Results'));
+        overviewTable(overview);
+        console.log(
+          chalk.dim(`  View full results: https://codequiry.com/results/${check.id}\n`)
+        );
+      }
+
+      // Exit code based on results for CI
+      if (options.threshold) {
+        const submissions = overview?.submissions || overview || [];
+        const maxScore = Math.max(
+          ...submissions.map((s) => parseFloat(s.result1 || s.total_result || 0))
+        );
+        if (maxScore > parseFloat(options.threshold)) {
+          process.exit(1);
+        }
+      }
+    } catch (error) {
+      if (!isJson) {
+        console.log(chalk.dim(`\n  View results at: https://codequiry.com/results/${check.id}\n`));
+      }
+    }
+  }
+}
+
+module.exports = scanCommand;

package/src/commands/start.js

@@ -0,0 +1,76 @@
+'use strict';
+
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const ora = require('ora');
+const { requireAuth } = require('../utils/errors');
+const { listChecks, startCheck } = require('../api/endpoints');
+
+async function startCommand(options) {
+  requireAuth();
+
+  let checkId = options.checkId;
+  let webcheck = options.web ? 1 : 0;
+  let dbcheck = options.db ? 1 : 0;
+
+  // If no check ID, let user pick one
+  if (!checkId) {
+    const spinner = ora('Fetching checks...').start();
+    let checks;
+    try {
+      const data = await listChecks();
+      checks = Array.isArray(data) ? data : data?.checks || [];
+      spinner.stop();
+    } catch (error) {
+      spinner.fail('Failed to fetch checks.');
+      return;
+    }
+
+    if (checks.length === 0) {
+      console.log(chalk.yellow('\n⚠ No checks found. Create one first.\n'));
+      return;
+    }
+
+    const { selectedCheck } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'selectedCheck',
+        message: 'Select a check to start:',
+        choices: checks.map((c) => ({
+          name: `${c.id} - ${c.name} (${c.submission_count || 0} submissions)`,
+          value: c.id,
+        })),
+      },
+    ]);
+    checkId = selectedCheck;
+  }
+
+  // Ask about check options if not set via flags
+  if (!options.web && !options.db && process.stdout.isTTY) {
+    const { checkOptions } = await inquirer.prompt([
+      {
+        type: 'checkbox',
+        name: 'checkOptions',
+        message: 'Check options (space to select):',
+        choices: [
+          { name: 'Web check (search online sources)', value: 'web' },
+          { name: 'Database check (search our database)', value: 'db' },
+        ],
+      },
+    ]);
+    webcheck = checkOptions.includes('web') ? 1 : 0;
+    dbcheck = checkOptions.includes('db') ? 1 : 0;
+  }
+
+  const spinner = ora('Starting check...').start();
+
+  try {
+    await startCheck(checkId, webcheck, dbcheck);
+    spinner.succeed(`Check ${chalk.cyan(checkId)} started!`);
+    console.log(chalk.dim('  Run `codequiry status --check ' + checkId + '` to monitor progress.\n'));
+  } catch (error) {
+    spinner.fail('Failed to start check.');
+  }
+}
+
+module.exports = startCommand;

package/src/commands/status.js

@@ -0,0 +1,65 @@
+'use strict';
+
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const ora = require('ora');
+const { requireAuth } = require('../utils/errors');
+const { listChecks, getCheckStatus } = require('../api/endpoints');
+const { pollUntilComplete } = require('../utils/poller');
+const { statusColor } = require('../utils/display');
+
+async function statusCommand(options) {
+  requireAuth();
+
+  let checkId = options.check;
+
+  if (!checkId) {
+    const spinner = ora('Fetching checks...').start();
+    let checks;
+    try {
+      const data = await listChecks();
+      checks = Array.isArray(data) ? data : data?.checks || [];
+      spinner.stop();
+    } catch (error) {
+      spinner.fail('Failed to fetch checks.');
+      return;
+    }
+
+    if (checks.length === 0) {
+      console.log(chalk.yellow('\n⚠ No checks found.\n'));
+      return;
+    }
+
+    const { selectedCheck } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'selectedCheck',
+        message: 'Select a check:',
+        choices: checks.map((c) => ({
+          name: `${c.id} - ${c.name}`,
+          value: c.id,
+        })),
+      },
+    ]);
+    checkId = selectedCheck;
+  }
+
+  if (options.poll) {
+    // Live polling mode
+    await pollUntilComplete(checkId);
+  } else {
+    // One-shot status check
+    const spinner = ora('Checking status...').start();
+    try {
+      const status = await getCheckStatus(checkId);
+      spinner.stop();
+      const s = status?.status || 'Unknown';
+      const p = status?.progress ?? '';
+      console.log(`\n  Check ${chalk.cyan(checkId)}: ${statusColor(s)}${p ? ` (${p}%)` : ''}\n`);
+    } catch (error) {
+      spinner.fail('Failed to fetch status.');
+    }
+  }
+}
+
+module.exports = statusCommand;

package/src/commands/upload.js

@@ -0,0 +1,102 @@
+'use strict';
+
+const path = require('path');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const ora = require('ora');
+const { requireAuth } = require('../utils/errors');
+const { listChecks, uploadZip, uploadBatch } = require('../api/endpoints');
+const { prepareUploads, cleanupTempFiles } = require('../utils/zipper');
+
+async function uploadCommand(inputPath, options) {
+  requireAuth();
+
+  let checkId = options.checkId;
+
+  // If no check ID, let user pick one
+  if (!checkId) {
+    const spinner = ora('Fetching checks...').start();
+    let checks;
+    try {
+      const data = await listChecks();
+      checks = Array.isArray(data) ? data : data?.checks || [];
+      spinner.stop();
+    } catch (error) {
+      spinner.fail('Failed to fetch checks.');
+      return;
+    }
+
+    if (checks.length === 0) {
+      console.log(chalk.yellow('\n⚠ No checks found. Create one first with `codequiry create`.\n'));
+      return;
+    }
+
+    const { selectedCheck } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'selectedCheck',
+        message: 'Select a check:',
+        choices: checks.map((c) => ({
+          name: `${c.id} - ${c.name} (${c.language_name || c.language || ''})`,
+          value: c.id,
+        })),
+      },
+    ]);
+    checkId = selectedCheck;
+  }
+
+  // Get input path if not provided
+  if (!inputPath) {
+    const { filePath } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'filePath',
+        message: 'Path to file or folder:',
+        default: '.',
+        validate: (input) => {
+          const resolved = path.resolve(input);
+          const fs = require('fs');
+          return fs.existsSync(resolved) ? true : 'Path does not exist';
+        },
+      },
+    ]);
+    inputPath = filePath;
+  }
+
+  const resolvedPath = path.resolve(inputPath);
+
+  // Zip if needed
+  const zipSpinner = ora('Preparing files...').start();
+  let zipFiles;
+  try {
+    zipFiles = await prepareUploads(resolvedPath);
+    zipSpinner.succeed(`Prepared ${zipFiles.length} file(s) for upload`);
+  } catch (error) {
+    zipSpinner.fail('Failed to prepare files: ' + error.message);
+    return;
+  }
+
+  // Upload
+  const uploadSpinner = ora('Uploading...').start();
+  try {
+    if (zipFiles.length === 1) {
+      await uploadZip(checkId, zipFiles[0]);
+    } else {
+      // Batch upload in chunks of 50
+      for (let i = 0; i < zipFiles.length; i += 50) {
+        const chunk = zipFiles.slice(i, i + 50);
+        await uploadBatch(checkId, chunk);
+        if (zipFiles.length > 50) {
+          uploadSpinner.text = `Uploading... (${Math.min(i + 50, zipFiles.length)}/${zipFiles.length})`;
+        }
+      }
+    }
+    uploadSpinner.succeed(`Uploaded ${zipFiles.length} file(s) to check ${chalk.cyan(checkId)}`);
+  } catch (error) {
+    uploadSpinner.fail('Upload failed.');
+  } finally {
+    cleanupTempFiles(zipFiles);
+  }
+}
+
+module.exports = uploadCommand;