hiresquire-cli 1.1.0 → 1.2.1

package/dist/api.js

@@ -0,0 +1,689 @@
+"use strict";
+/**
+ * HireSquire CLI - API Client
+ *
+ * HTTP client for interacting with the HireSquire API
+ * Handles authentication, request/response typing, and error handling
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiClient = void 0;
+exports.createApiClient = createApiClient;
+exports.createApiClientFromToken = createApiClientFromToken;
+exports.readResumeFromFile = readResumeFromFile;
+exports.readResumesFromDirectory = readResumesFromDirectory;
+exports.readResumesFromPaths = readResumesFromPaths;
+const axios_1 = __importDefault(require("axios"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const pdf_parse_1 = __importDefault(require("pdf-parse"));
+const officeparser_1 = __importDefault(require("officeparser"));
+const form_data_1 = __importDefault(require("form-data"));
+const types_1 = require("./types");
+// ============================================================================
+// Constants
+// ============================================================================
+const DEFAULT_BASE_URL = 'https://api.hiresquireai.com/api/v1';
+const DEFAULT_TIMEOUT = 30000; // 30 seconds
+const MAX_RETRIES = 3;
+const RETRY_DELAY = 1000; // 1 second base delay
+const MAX_FILE_SIZE = 20 * 1024 * 1024; // 20MB max file size
+// ============================================================================
+// API Client Class
+// ============================================================================
+class ApiClient {
+    constructor(config) {
+        this.config = {
+            ...config,
+            baseUrl: config.baseUrl || DEFAULT_BASE_URL,
+        };
+        this.client = axios_1.default.create({
+            baseURL: this.config.baseUrl,
+            timeout: DEFAULT_TIMEOUT,
+            headers: {
+                'Authorization': `Bearer ${this.config.apiToken}`,
+                'Content-Type': 'application/json',
+                'Accept': 'application/json',
+                'User-Agent': 'hiresquire-cli/1.2.1',
+            },
+        });
+        // Add response interceptor for error handling with retry
+        this.client.interceptors.response.use((response) => response, async (error) => {
+            const originalRequest = error.config;
+            if (!originalRequest) {
+                throw this.handleError(error);
+            }
+            const shouldRetry = this.shouldRetryRequest(error);
+            const retryCount = originalRequest._retryCount || 0;
+            if (shouldRetry && retryCount < MAX_RETRIES) {
+                originalRequest._retryCount = retryCount + 1;
+                const delay = RETRY_DELAY * Math.pow(2, retryCount);
+                await this.sleep(delay);
+                return this.client(originalRequest);
+            }
+            throw this.handleError(error);
+        });
+    }
+    shouldRetryRequest(error) {
+        const statusCode = error.response?.status;
+        const code = error.code;
+        // Retry on: rate limit, server errors, timeouts, and network errors
+        const retryableCodes = ['ECONNABORTED', 'ETIMEDOUT', 'ENOTFOUND', 'ECONNREFUSED'];
+        return statusCode === 429 || statusCode === 503 || statusCode === 500 || retryableCodes.includes(code || '');
+    }
+    // ============================================================================
+    // Error Handling
+    // ============================================================================
+    handleError(error) {
+        const statusCode = error.response?.status;
+        const responseData = error.response?.data;
+        const message = responseData?.message || responseData?.error || error.message;
+        switch (statusCode) {
+            case 401:
+            case 403:
+                return new types_1.AuthenticationError(message);
+            case 400:
+                return new types_1.ValidationError(message);
+            case 404:
+                return new types_1.NotFoundError(message);
+            case 429:
+                const retryAfter = error.response?.headers['retry-after'];
+                return new types_1.RateLimitError(message + (retryAfter ? ` Retry after ${retryAfter} seconds.` : ''));
+            case 422:
+                return new types_1.ValidationError(message);
+            default:
+                return new types_1.HireSquireError(message, 'API_ERROR', statusCode);
+        }
+    }
+    // ============================================================================
+    // Job Operations
+    // ============================================================================
+    /**
+     * Generic GET request
+     */
+    async get(url, config) {
+        const response = await this.client.get(url, config);
+        return { data: response.data };
+    }
+    /**
+     * Generic POST request
+     */
+    async post(url, data, config) {
+        const response = await this.client.post(url, data, config);
+        return { data: response.data };
+    }
+    /**
+     * Generic PUT request
+     */
+    async put(url, data, config) {
+        const response = await this.client.put(url, data, config);
+        return { data: response.data };
+    }
+    /**
+     * Generic DELETE request
+     */
+    async delete(url, config) {
+        const response = await this.client.delete(url, config);
+        return { data: response.data };
+    }
+    /**
+     * Create a new screening job
+     */
+    async createJob(params) {
+        const response = await this.client.post('/jobs', params);
+        return response.data;
+    }
+    /**
+     * Upload a ZIP file containing resumes to create a new screening job
+     */
+    async uploadZip(params) {
+        const formData = new form_data_1.default();
+        formData.append('title', params.title);
+        formData.append('description', params.description);
+        if (params.leniency_level !== undefined) {
+            formData.append('leniency_level', params.leniency_level.toString());
+        }
+        if (params.custom_instructions) {
+            formData.append('custom_instructions', params.custom_instructions);
+        }
+        if (params.webhook_url) {
+            formData.append('webhook_url', params.webhook_url);
+        }
+        // Append the zip file
+        formData.append('zip_file', fs.createReadStream(params.zipPath));
+        const response = await this.client.post('/jobs/upload-zip', formData, {
+            headers: {
+                ...formData.getHeaders()
+            }
+        });
+        return response.data;
+    }
+    /**
+     * Get job status
+     */
+    async getJobStatus(jobId) {
+        const response = await this.client.get(`/jobs/${jobId}`);
+        return response.data;
+    }
+    /**
+     * Get job results
+     */
+    async getResults(jobId, options = {}) {
+        const params = new URLSearchParams();
+        if (options.min_score)
+            params.append('min_score', options.min_score.toString());
+        if (options.only_top_n)
+            params.append('only_top_n', options.only_top_n.toString());
+        const queryString = params.toString();
+        const url = queryString
+            ? `/jobs/${jobId}/results?${queryString}`
+            : `/jobs/${jobId}/results`;
+        const response = await this.client.get(url);
+        return response.data;
+    }
+    /**
+     * List all jobs
+     */
+    async listJobs(options = {}) {
+        const params = new URLSearchParams();
+        if (options.status)
+            params.append('status', options.status);
+        if (options.page)
+            params.append('page', options.page.toString());
+        if (options.per_page)
+            params.append('per_page', options.per_page.toString());
+        const queryString = params.toString();
+        const url = queryString ? `/jobs?${queryString}` : '/jobs';
+        const response = await this.client.get(url);
+        return response.data;
+    }
+    // ============================================================================
+    // Email Operations
+    // ============================================================================
+    /**
+     * Generate an email for a candidate
+     */
+    async generateEmail(params) {
+        const response = await this.client.post(`/jobs/${params.job_id}/generate-email`, {
+            candidate_id: params.candidate_id,
+            type: params.type,
+            custom_message: params.custom_message,
+        });
+        return response.data;
+    }
+    // ============================================================================
+    // Utility Methods
+    // ============================================================================
+    /**
+     * Poll for job completion
+     */
+    async pollForCompletion(jobId, options = {}) {
+        const interval = options.interval || 3000; // 3 seconds
+        const timeout = options.timeout || 300000; // 5 minutes
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeout) {
+            const status = await this.getJobStatus(jobId);
+            if (options.onProgress) {
+                options.onProgress(status);
+            }
+            if (status.status === 'completed' || status.status === 'failed') {
+                return status;
+            }
+            await this.sleep(interval);
+        }
+        throw new types_1.HireSquireError(`Job polling timed out after ${timeout / 1000} seconds`, 'TIMEOUT');
+    }
+    /**
+     * Sleep for specified milliseconds
+     */
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    /**
+     * Test API connection
+     */
+    async testConnection() {
+        try {
+            await this.listJobs({ per_page: 1 });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get current config
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    // ============================================================================
+    // Job Control
+    // ============================================================================
+    /**
+     * Cancel a running job
+     */
+    async cancelJob(jobId) {
+        const response = await this.client.post(`/jobs/${jobId}/cancel`);
+        return response.data;
+    }
+    /**
+     * Compare multiple candidates side-by-side
+     */
+    async compareCandidates(jobId, candidateIds) {
+        const response = await this.client.get(`/jobs/${jobId}/compare?ids=${candidateIds.join(',')}`);
+        return response.data;
+    }
+    /**
+     * Report hiring outcome to improve AI accuracy
+     */
+    async reportOutcome(jobId, candidateId, outcome) {
+        const response = await this.client.post(`/jobs/${jobId}/outcome`, { candidate_id: candidateId, outcome });
+        return response.data;
+    }
+    // ============================================================================
+    // Webhook
+    // ============================================================================
+    /**
+     * Test a webhook endpoint
+     */
+    async testWebhook(webhookUrl) {
+        const response = await this.client.post('/webhooks/test', { url: webhookUrl });
+        return response.data;
+    }
+    // ============================================================================
+    // Rate Limit
+    // ============================================================================
+    /**
+     * Get current rate limit status
+     */
+    async getRateLimit() {
+        const response = await this.client.get('/rate-limit');
+        return response.data;
+    }
+    // ============================================================================
+    // Candidate Operations
+    // ============================================================================
+    /**
+     * Get a specific candidate
+     */
+    async getCandidate(candidateId) {
+        const response = await this.client.get(`/candidates/${candidateId}`);
+        return response.data;
+    }
+    /**
+     * Update candidate status
+     */
+    async updateCandidateStatus(candidateId, status) {
+        const response = await this.client.patch(`/candidates/${candidateId}/status`, { status });
+        return response.data;
+    }
+    // ============================================================================
+    // Schema Discovery
+    // ============================================================================
+    /**
+     * Get API schema for discovery
+     */
+    async getSchema() {
+        const response = await this.client.get('/schema');
+        return response.data;
+    }
+    // ===========================================================================
+    // Calendar Operations
+    // ===========================================================================
+    /**
+     * List calendar connections
+     */
+    async listCalendarConnections() {
+        const response = await this.client.get('/calendar/connections');
+        return response.data;
+    }
+    /**
+     * Create a calendar connection
+     */
+    async createCalendarConnection(params) {
+        const response = await this.client.post('/calendar/connections', params);
+        return response.data;
+    }
+    /**
+     * Delete a calendar connection
+     */
+    async deleteCalendarConnection(id) {
+        const response = await this.client.delete(`/calendar/connections/${id}`);
+        return response.data;
+    }
+    /**
+     * Get available slots from calendar
+     */
+    async getAvailableSlots(params) {
+        const response = await this.client.get('/calendar/slots', { params });
+        return response.data;
+    }
+    // ===========================================================================
+    // Interview Operations
+    // ===========================================================================
+    /**
+     * List interviews
+     */
+    async listInterviews(jobId) {
+        const params = jobId ? { job_id: jobId } : {};
+        const response = await this.client.get('/interviews', { params });
+        return response.data;
+    }
+    /**
+     * Create an interview
+     */
+    async createInterview(params) {
+        const response = await this.client.post('/interviews', params);
+        return response.data;
+    }
+    /**
+     * Show a specific interview
+     */
+    async showInterview(id) {
+        const response = await this.client.get(`/interviews/${id}`);
+        return response.data;
+    }
+    /**
+     * Update an interview
+     */
+    async updateInterview(id, params) {
+        const response = await this.client.put(`/interviews/${id}`, params);
+        return response.data;
+    }
+    /**
+     * Delete/cancel an interview
+     */
+    async deleteInterview(id) {
+        const response = await this.client.delete(`/interviews/${id}`);
+        return response.data;
+    }
+    // ===========================================================================
+    // Meeting Operations
+    // ===========================================================================
+    /**
+     * Generate a meeting link
+     */
+    async generateMeetingLink(params) {
+        const response = await this.client.post('/meetings/links', params);
+        return response.data;
+    }
+}
+exports.ApiClient = ApiClient;
+// ===========================================================================
+// Factory Functions
+// ============================================================================
+// Factory Functions
+// ============================================================================
+/**
+ * Create API client from config
+ */
+function createApiClient(config) {
+    return new ApiClient(config);
+}
+/**
+ * Create API client from token
+ */
+function createApiClientFromToken(token, baseUrl) {
+    return new ApiClient({
+        apiToken: token,
+        baseUrl: baseUrl || DEFAULT_BASE_URL,
+    });
+}
+// ============================================================================
+// Resume Parsing Utilities
+// ============================================================================
+/**
+ * Read resume from file path (async - supports PDF, DOCX, DOC, TXT, MD)
+ */
+async function readResumeFromFile(filePath) {
+    const absolutePath = path.resolve(filePath);
+    if (!fs.existsSync(absolutePath)) {
+        throw new Error(`File not found: ${filePath}`);
+    }
+    const stats = fs.statSync(absolutePath);
+    if (stats.size > MAX_FILE_SIZE) {
+        throw new Error(`File too large: ${filePath} (max ${MAX_FILE_SIZE / 1024 / 1024}MB)`);
+    }
+    const filename = path.basename(filePath);
+    const ext = path.extname(filePath).toLowerCase();
+    let content;
+    try {
+        if (ext === '.pdf') {
+            content = await parsePdf(absolutePath);
+        }
+        else if (ext === '.docx') {
+            content = await parseDocx(absolutePath);
+        }
+        else if (ext === '.doc') {
+            content = await parseDoc(absolutePath);
+        }
+        else if (['.txt', '.md'].includes(ext)) {
+            content = fs.readFileSync(absolutePath, 'utf-8');
+        }
+        else {
+            throw new Error(`Unsupported file format: ${ext}`);
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to parse ${filePath}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+    // Validate extracted content
+    if (!content || content.trim().length < 50) {
+        throw new Error(`Could not extract sufficient text from: ${filePath}`);
+    }
+    return { filename, content };
+}
+/**
+ * Parse PDF file and extract text
+ */
+async function parsePdf(filePath) {
+    try {
+        const dataBuffer = fs.readFileSync(filePath);
+        const data = await (0, pdf_parse_1.default)(dataBuffer);
+        return data.text || '';
+    }
+    catch (error) {
+        throw new Error(`PDF parsing failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+/**
+ * Parse DOCX file and extract text
+ */
+async function parseDocx(filePath) {
+    try {
+        // officeparser returns AST, convert to plain text
+        const result = await new Promise((resolve, reject) => {
+            officeparser_1.default.parseOffice(filePath, (data) => {
+                const text = officeparser_1.default.toText(data);
+                resolve({ content: text || '' });
+            }, (error) => {
+                reject(error);
+            });
+        });
+        return result.content || '';
+    }
+    catch (error) {
+        throw new Error(`DOCX parsing failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+/**
+ * Parse DOC file and extract text (uses same parser as DOCX)
+ */
+async function parseDoc(filePath) {
+    // officeparser supports DOC files as well
+    return parseDocx(filePath);
+}
+/**
+ * Read resumes from directory (async)
+ */
+async function readResumesFromDirectory(dirPath, currentCount = 0) {
+    const absolutePath = path.resolve(dirPath);
+    if (!fs.existsSync(absolutePath)) {
+        return [];
+    }
+    const files = fs.readdirSync(absolutePath);
+    const resumeExtensions = ['.txt', '.pdf', '.doc', '.docx', '.md'];
+    const resumes = [];
+    for (const file of files) {
+        if (currentCount + resumes.length >= 100)
+            break;
+        const ext = path.extname(file).toLowerCase();
+        if (resumeExtensions.includes(ext)) {
+            const filePath = path.join(absolutePath, file);
+            try {
+                resumes.push(await readResumeFromFile(filePath));
+            }
+            catch (error) {
+                console.warn(`Warning: Could not read ${file}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+        }
+    }
+    return resumes;
+}
+/**
+ * Read multiple resume files (async)
+ */
+async function readResumesFromPaths(paths) {
+    const resumes = [];
+    for (const p of paths) {
+        if (resumes.length >= 100) {
+            break;
+        }
+        const resolvedPath = path.resolve(p);
+        // Check if it's a glob pattern
+        if (p.includes('*')) {
+            const patternMatches = await matchGlobPattern(resolvedPath, resumes.length);
+            resumes.push(...patternMatches);
+            continue;
+        }
+        try {
+            const stat = fs.statSync(resolvedPath);
+            if (stat.isDirectory()) {
+                const dirResumes = await readResumesFromDirectory(resolvedPath, resumes.length);
+                resumes.push(...dirResumes);
+            }
+            else if (stat.isFile()) {
+                resumes.push(await readResumeFromFile(resolvedPath));
+            }
+        }
+        catch (error) {
+            console.warn(`Warning: Could not read ${p}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    if (resumes.length >= 100) {
+        console.warn('⚠️ Maximum limit of 100 resumes reached. Additional files in this batch were ignored.');
+    }
+    return resumes.slice(0, 100);
+}
+/**
+ * Match glob patterns for resume files (async)
+ */
+async function matchGlobPattern(pattern, currentCount = 0) {
+    const resumes = [];
+    const resumeExtensions = ['.txt', '.pdf', '.doc', '.docx', '.md'];
+    // Handle **/*.ext patterns (recursive)
+    if (pattern.includes('**')) {
+        const parts = pattern.split('**');
+        const baseDir = path.resolve(parts[0] || '.');
+        const suffix = parts[1] || '';
+        async function walk(dir) {
+            if (!fs.existsSync(dir))
+                return;
+            if (currentCount + resumes.length >= 100)
+                return;
+            const files = fs.readdirSync(dir);
+            for (const file of files) {
+                if (currentCount + resumes.length >= 100)
+                    break;
+                const fullPath = path.join(dir, file);
+                const stat = fs.statSync(fullPath);
+                if (stat.isDirectory()) {
+                    await walk(fullPath);
+                }
+                else if (stat.isFile()) {
+                    const ext = path.extname(file).toLowerCase();
+                    if (resumeExtensions.includes(ext)) {
+                        if (!suffix || fullPath.endsWith(suffix.replace('/', path.sep))) {
+                            try {
+                                resumes.push(await readResumeFromFile(fullPath));
+                            }
+                            catch (e) {
+                                console.warn(`Warning: Could not read ${file}: ${e.message}`);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        await walk(baseDir);
+        return resumes;
+    }
+    // Standard glob implementation (non-recursive)
+    const lastSlash = pattern.lastIndexOf(path.sep);
+    let searchDir = '.';
+    let filePattern = pattern;
+    if (lastSlash >= 0) {
+        searchDir = pattern.slice(0, lastSlash);
+        filePattern = pattern.slice(lastSlash + 1);
+    }
+    const searchPath = path.resolve(searchDir);
+    if (!fs.existsSync(searchPath)) {
+        return resumes;
+    }
+    const regexPattern = new RegExp('^' + filePattern.replace(/\./g, '\\.').replace(/\*/g, '.*') + '$', 'i');
+    const files = fs.readdirSync(searchPath);
+    for (const file of files) {
+        if (currentCount + resumes.length >= 100)
+            break;
+        if (regexPattern.test(file)) {
+            const ext = path.extname(file).toLowerCase();
+            if (resumeExtensions.includes(ext)) {
+                const filePath = path.join(searchPath, file);
+                try {
+                    resumes.push(await readResumeFromFile(filePath));
+                }
+                catch (e) {
+                    console.warn(`Warning: Could not read ${file}: ${e.message}`);
+                }
+            }
+        }
+    }
+    return resumes;
+}
+//# sourceMappingURL=api.js.map