propr-cli 0.8.3

package/dist/api/repos.js

@@ -0,0 +1,243 @@
+/**
+ * Repository Configuration API
+ *
+ * Functions for interacting with the ProPR backend repository configuration endpoints.
+ * These functions provide a typed interface to list, add, update, and remove monitored repositories.
+ */
+import { createApiClient } from "./index.js";
+/**
+ * Fetches the list of monitored repositories.
+ *
+ * @param client - Optional ApiClient instance. If not provided, one will be created.
+ * @returns A promise resolving to the list of monitored repositories.
+ *
+ * @example
+ * ```typescript
+ * const result = await getRepos();
+ * console.log(`Monitoring ${result.repos_to_monitor.length} repositories`);
+ * for (const repo of result.repos_to_monitor) {
+ *   console.log(`- ${repo.name} (${repo.enabled ? 'enabled' : 'disabled'})`);
+ * }
+ * ```
+ */
+export async function getRepos(client) {
+    const apiClient = client ?? (await createApiClient());
+    const response = await apiClient.get("/api/config/repos");
+    return response.data;
+}
+/**
+ * Adds a new repository to the monitored list.
+ *
+ * @param fullName - The full repository name in "owner/repo" format.
+ * @param options - Optional configuration for the repository.
+ * @param client - Optional ApiClient instance. If not provided, one will be created.
+ * @returns A promise resolving to the updated repository configuration.
+ *
+ * @example
+ * ```typescript
+ * // Add a repository with default settings
+ * const result = await addRepo("owner/repo");
+ *
+ * // Add a repository with custom settings
+ * const result = await addRepo("owner/repo", {
+ *   alias: "my-project",
+ *   baseBranch: "develop"
+ * });
+ * ```
+ */
+export async function addRepo(fullName, options = {}, client) {
+    const apiClient = client ?? (await createApiClient());
+    // First, fetch the current list of repos
+    const currentRepos = await getRepos(apiClient);
+    // Check if repo already exists
+    const existingRepo = currentRepos.repos_to_monitor.find((r) => r.name.toLowerCase() === fullName.toLowerCase());
+    if (existingRepo) {
+        throw new Error(`Repository "${fullName}" is already being monitored`);
+    }
+    // Create new repo entry
+    const newRepo = {
+        id: crypto.randomUUID(),
+        name: fullName,
+        enabled: options.enabled ?? true,
+        alias: options.alias?.trim() || undefined,
+        baseBranch: options.baseBranch?.trim() || undefined,
+    };
+    // Add to list and save
+    const updatedRepos = [...currentRepos.repos_to_monitor, newRepo];
+    const response = await apiClient.post("/api/config/repos", {
+        body: { repos_to_monitor: updatedRepos },
+    });
+    return response.data;
+}
+/**
+ * Updates an existing monitored repository.
+ *
+ * @param fullName - The full repository name in "owner/repo" format.
+ * @param updates - The fields to update.
+ * @param client - Optional ApiClient instance. If not provided, one will be created.
+ * @returns A promise resolving to the updated repository configuration.
+ *
+ * @example
+ * ```typescript
+ * // Enable a repository
+ * const result = await updateRepo("owner/repo", { enabled: true });
+ *
+ * // Update multiple fields
+ * const result = await updateRepo("owner/repo", {
+ *   alias: "new-alias",
+ *   baseBranch: "main"
+ * });
+ * ```
+ */
+export async function updateRepo(fullName, updates, client) {
+    const apiClient = client ?? (await createApiClient());
+    // Fetch current repos
+    const currentRepos = await getRepos(apiClient);
+    // Find the repo to update
+    const repoIndex = currentRepos.repos_to_monitor.findIndex((r) => r.name.toLowerCase() === fullName.toLowerCase());
+    if (repoIndex === -1) {
+        throw new Error(`Repository "${fullName}" is not being monitored`);
+    }
+    // Apply updates
+    const existingRepo = currentRepos.repos_to_monitor[repoIndex];
+    const updatedRepo = {
+        ...existingRepo,
+        ...(updates.enabled !== undefined && { enabled: updates.enabled }),
+        ...(updates.alias !== undefined && { alias: updates.alias?.trim() || undefined }),
+        ...(updates.baseBranch !== undefined && { baseBranch: updates.baseBranch?.trim() || undefined }),
+    };
+    // Replace in list
+    const updatedRepos = [...currentRepos.repos_to_monitor];
+    updatedRepos[repoIndex] = updatedRepo;
+    const response = await apiClient.post("/api/config/repos", {
+        body: { repos_to_monitor: updatedRepos },
+    });
+    return response.data;
+}
+/**
+ * Removes a repository from the monitored list.
+ *
+ * @param fullName - The full repository name in "owner/repo" format.
+ * @param client - Optional ApiClient instance. If not provided, one will be created.
+ * @returns A promise resolving to the updated repository configuration.
+ *
+ * @example
+ * ```typescript
+ * const result = await removeRepo("owner/repo");
+ * console.log(`Now monitoring ${result.repos_to_monitor.length} repositories`);
+ * ```
+ */
+export async function removeRepo(fullName, client) {
+    const apiClient = client ?? (await createApiClient());
+    // Fetch current repos
+    const currentRepos = await getRepos(apiClient);
+    // Find the repo to remove
+    const repoIndex = currentRepos.repos_to_monitor.findIndex((r) => r.name.toLowerCase() === fullName.toLowerCase());
+    if (repoIndex === -1) {
+        throw new Error(`Repository "${fullName}" is not being monitored`);
+    }
+    // Remove from list
+    const updatedRepos = currentRepos.repos_to_monitor.filter((_, index) => index !== repoIndex);
+    const response = await apiClient.post("/api/config/repos", {
+        body: { repos_to_monitor: updatedRepos },
+    });
+    return response.data;
+}
+/**
+ * Triggers indexing for a repository.
+ *
+ * @param fullName - The full repository name in "owner/repo" format.
+ * @param options - Optional indexing options.
+ * @param options.fullReindex - Whether to perform a full reindex. Defaults to true.
+ * @param options.baseBranch - The base branch to index.
+ * @param client - Optional ApiClient instance. If not provided, one will be created.
+ * @returns A promise resolving to the trigger indexing response.
+ *
+ * @example
+ * ```typescript
+ * // Trigger full reindexing for a repository
+ * const result = await triggerIndexing("owner/repo");
+ * console.log(`Indexing started with job ID: ${result.jobId}`);
+ *
+ * // Trigger indexing for a specific branch
+ * const result = await triggerIndexing("owner/repo", { baseBranch: "develop" });
+ * ```
+ */
+export async function triggerIndexing(fullName, options = {}, client) {
+    const apiClient = client ?? (await createApiClient());
+    const response = await apiClient.post("/api/config/repos/trigger-indexing", {
+        body: {
+            repository: fullName,
+            fullReindex: options.fullReindex ?? true,
+            baseBranch: options.baseBranch,
+        },
+    });
+    return response.data;
+}
+/**
+ * Gets the indexing status for all repositories or filters for a specific repository.
+ *
+ * @param fullName - Optional. The full repository name in "owner/repo" format to filter by.
+ * @param client - Optional ApiClient instance. If not provided, one will be created.
+ * @returns A promise resolving to the indexing status response.
+ *
+ * @example
+ * ```typescript
+ * // Get indexing status for all repositories
+ * const result = await getIndexingStatus();
+ * for (const repo of result.repositories) {
+ *   console.log(`${repo.full_name}: ${repo.indexing_status}`);
+ * }
+ *
+ * // Get indexing status for a specific repository
+ * const result = await getIndexingStatus("owner/repo");
+ * const status = result.repositories[0];
+ * if (status?.progress) {
+ *   console.log(`Progress: ${status.progress.percentComplete}%`);
+ * }
+ * ```
+ */
+export async function getIndexingStatus(fullName, client) {
+    const apiClient = client ?? (await createApiClient());
+    const response = await apiClient.get("/api/config/repos/indexing-status");
+    // Filter by fullName if provided
+    if (fullName) {
+        const filtered = response.data.repositories.filter((repo) => repo.full_name.toLowerCase() === fullName.toLowerCase());
+        return { repositories: filtered };
+    }
+    return response.data;
+}
+/**
+ * Repository API namespace providing all repository configuration operations.
+ *
+ * @example
+ * ```typescript
+ * import { reposApi } from "@propr/cli/api";
+ *
+ * // List all monitored repos
+ * const { repos_to_monitor } = await reposApi.getRepos();
+ *
+ * // Add a new repo
+ * await reposApi.addRepo("owner/repo", { alias: "my-project" });
+ *
+ * // Update a repo
+ * await reposApi.updateRepo("owner/repo", { enabled: false });
+ *
+ * // Remove a repo
+ * await reposApi.removeRepo("owner/repo");
+ *
+ * // Trigger indexing
+ * await reposApi.triggerIndexing("owner/repo");
+ *
+ * // Get indexing status
+ * const status = await reposApi.getIndexingStatus("owner/repo");
+ * ```
+ */
+export const reposApi = {
+    getRepos,
+    addRepo,
+    updateRepo,
+    removeRepo,
+    triggerIndexing,
+    getIndexingStatus,
+};

package/dist/api/settings.js

@@ -0,0 +1,219 @@
+/**
+ * System Settings API
+ *
+ * Functions for interacting with the ProPR backend system settings endpoints.
+ * These functions provide a typed interface to view and update global system configuration
+ * like worker concurrency, auto-followup thresholds, and model settings.
+ */
+import { createApiClient } from "./index.js";
+/**
+ * Maximum allowed length for the free-form `pr_review_prompt` setting.
+ * Mirrors the server-side limit enforced in the config routes.
+ */
+const MAX_PR_REVIEW_PROMPT_LENGTH = 20000;
+/**
+ * List of valid setting keys for validation.
+ */
+export const VALID_SETTING_KEYS = [
+    "default_agent_alias",
+    "worker_concurrency",
+    "github_user_whitelist",
+    "analysis_model_fast",
+    "planner_context_model",
+    "planner_generation_model",
+    "auto_followup_score_threshold",
+    "auto_resolve_merge_conflicts",
+    "pr_review_model",
+    "pr_review_prompt",
+    "ultrafix_rating_goal",
+    "ultrafix_max_cycles",
+    "ultrafix_pause_seconds",
+];
+/**
+ * Validates if a string is a valid setting key.
+ *
+ * @param key - The key to validate.
+ * @returns True if the key is valid, false otherwise.
+ */
+export function isValidSettingKey(key) {
+    return VALID_SETTING_KEYS.includes(key);
+}
+/**
+ * Parses a value string to the appropriate type for the given setting key.
+ *
+ * @param key - The setting key.
+ * @param value - The value string to parse.
+ * @returns The parsed value.
+ * @throws Error if the value cannot be parsed for the given key.
+ */
+export function parseSettingValue(key, value) {
+    switch (key) {
+        case "worker_concurrency":
+        case "auto_followup_score_threshold": {
+            if (!/^-?\d+$/.test(value)) {
+                throw new Error(`Invalid value for ${key}: must be an integer`);
+            }
+            const parsed = Number(value);
+            if (!Number.isSafeInteger(parsed)) {
+                throw new Error(`Invalid value for ${key}: must be an integer up to ${Number.MAX_SAFE_INTEGER}`);
+            }
+            if (key === "auto_followup_score_threshold" && (parsed < 0 || parsed > 9)) {
+                throw new Error(`Invalid value for ${key}: must be between 0 and 9`);
+            }
+            if (key === "worker_concurrency" && parsed < 1) {
+                throw new Error(`Invalid value for ${key}: must be at least 1`);
+            }
+            return parsed;
+        }
+        case "ultrafix_rating_goal": {
+            if (!/^\d+$/.test(value)) {
+                throw new Error(`Invalid value for ${key}: must be a positive integer between 1 and 10`);
+            }
+            const parsed = Number(value);
+            if (parsed < 1 || parsed > 10) {
+                throw new Error(`Invalid value for ${key}: must be a number between 1 and 10`);
+            }
+            return parsed;
+        }
+        case "ultrafix_max_cycles": {
+            if (!/^\d+$/.test(value)) {
+                throw new Error(`Invalid value for ${key}: must be a positive integer`);
+            }
+            const parsed = Number(value);
+            if (parsed < 1 || !Number.isSafeInteger(parsed)) {
+                throw new Error(`Invalid value for ${key}: must be a positive integer up to ${Number.MAX_SAFE_INTEGER}`);
+            }
+            return parsed;
+        }
+        case "ultrafix_pause_seconds": {
+            if (!/^\d+$/.test(value)) {
+                throw new Error(`Invalid value for ${key}: must be a non-negative integer`);
+            }
+            const parsed = Number(value);
+            if (parsed < 0 || !Number.isSafeInteger(parsed)) {
+                throw new Error(`Invalid value for ${key}: must be a non-negative integer up to ${Number.MAX_SAFE_INTEGER}`);
+            }
+            return parsed;
+        }
+        case "auto_resolve_merge_conflicts": {
+            const lower = value.toLowerCase();
+            if (lower !== "true" && lower !== "false") {
+                throw new Error(`Invalid value for ${key}: must be "true" or "false"`);
+            }
+            return lower === "true";
+        }
+        case "github_user_whitelist":
+            // Parse comma-separated list
+            return value.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+        case "analysis_model_fast":
+        case "default_agent_alias":
+        case "planner_context_model":
+        case "planner_generation_model":
+            return value;
+        case "pr_review_model": {
+            const trimmed = value.trim();
+            if (trimmed === '' && value.length > 0) {
+                throw new Error(`Invalid value for ${key}: must not be whitespace-only; use an empty string to clear`);
+            }
+            return trimmed;
+        }
+        case "pr_review_prompt": {
+            if (value.length > MAX_PR_REVIEW_PROMPT_LENGTH) {
+                throw new Error(`Invalid value for ${key}: must be at most ${MAX_PR_REVIEW_PROMPT_LENGTH} characters`);
+            }
+            return value;
+        }
+        default:
+            return value;
+    }
+}
+/**
+ * Fetches the current system settings.
+ *
+ * @param client - Optional ApiClient instance. If not provided, one will be created.
+ * @returns A promise resolving to the current system settings.
+ *
+ * @example
+ * ```typescript
+ * const settings = await getSettings();
+ * console.log(`Worker concurrency: ${settings.worker_concurrency}`);
+ * console.log(`Auto-followup threshold: ${settings.auto_followup_score_threshold}`);
+ * ```
+ */
+export async function getSettings(client) {
+    const apiClient = client ?? (await createApiClient());
+    const response = await apiClient.get("/api/config/settings");
+    return response.data;
+}
+/**
+ * Updates one or more system settings.
+ *
+ * @param settings - Object containing settings to update.
+ * @param client - Optional ApiClient instance. If not provided, one will be created.
+ * @returns A promise resolving to the update response.
+ *
+ * @example
+ * ```typescript
+ * // Update a single setting
+ * await updateSettings({ worker_concurrency: 10 });
+ *
+ * // Update multiple settings
+ * await updateSettings({
+ *   worker_concurrency: 10,
+ *   auto_followup_score_threshold: 7
+ * });
+ * ```
+ */
+export async function updateSettings(settings, client) {
+    const apiClient = client ?? (await createApiClient());
+    const response = await apiClient.post("/api/config/settings", {
+        body: { settings },
+    });
+    return response.data;
+}
+/**
+ * Updates a single system setting by key.
+ *
+ * @param key - The setting key to update.
+ * @param value - The new value for the setting.
+ * @param client - Optional ApiClient instance. If not provided, one will be created.
+ * @returns A promise resolving to the update response.
+ *
+ * @example
+ * ```typescript
+ * // Update worker concurrency
+ * await updateSetting("worker_concurrency", 10);
+ *
+ * // Update auto-followup threshold
+ * await updateSetting("auto_followup_score_threshold", 7);
+ * ```
+ */
+export async function updateSetting(key, value, client) {
+    const settings = { [key]: value };
+    return updateSettings(settings, client);
+}
+/**
+ * Settings API namespace providing all system settings operations.
+ *
+ * @example
+ * ```typescript
+ * import { settingsApi } from "@propr/cli/api";
+ *
+ * // Get current settings
+ * const settings = await settingsApi.getSettings();
+ *
+ * // Update settings
+ * await settingsApi.updateSettings({ worker_concurrency: 10 });
+ *
+ * // Update a single setting
+ * await settingsApi.updateSetting("auto_followup_score_threshold", 7);
+ * ```
+ */
+export const settingsApi = {
+    getSettings,
+    updateSettings,
+    updateSetting,
+    isValidSettingKey,
+    parseSettingValue,
+    VALID_SETTING_KEYS,
+};

package/dist/api/system.js

@@ -0,0 +1,53 @@
+/**
+ * System Status API
+ *
+ * Functions for interacting with the ProPR backend system status and queue endpoints.
+ * These functions provide a typed interface to check system health and queue statistics.
+ */
+import { createApiClient } from "./index.js";
+/**
+ * Fetches the current system status from the backend.
+ *
+ * This function retrieves health information about various backend components
+ * including the API, Redis, daemon, workers, and authentication status.
+ *
+ * @param client - Optional ApiClient instance. If not provided, one will be created.
+ * @returns A promise resolving to the system status.
+ *
+ * @example
+ * ```typescript
+ * // Get system status
+ * const status = await getSystemStatus();
+ * console.log(`API: ${status.api}`);
+ * console.log(`Redis: ${status.redis}`);
+ * console.log(`Workers: ${status.workerCount}`);
+ * ```
+ */
+export async function getSystemStatus(client) {
+    const apiClient = client ?? (await createApiClient());
+    const response = await apiClient.get("/api/status");
+    return response.data;
+}
+/**
+ * Fetches queue statistics from the backend.
+ *
+ * This function retrieves information about the current state of the task queue
+ * including counts of waiting, active, completed, failed, and delayed jobs.
+ *
+ * @param client - Optional ApiClient instance. If not provided, one will be created.
+ * @returns A promise resolving to the queue statistics.
+ *
+ * @example
+ * ```typescript
+ * // Get queue stats
+ * const stats = await getQueueStats();
+ * console.log(`Active: ${stats.active}`);
+ * console.log(`Completed: ${stats.completed}`);
+ * console.log(`Failed: ${stats.failed}`);
+ * ```
+ */
+export async function getQueueStats(client) {
+    const apiClient = client ?? (await createApiClient());
+    const response = await apiClient.get("/api/queue/stats");
+    return response.data;
+}

package/dist/api/tasks.js

@@ -0,0 +1,140 @@
+/**
+ * Tasks API
+ *
+ * Functions for interacting with the ProPR backend task management endpoints.
+ * These functions provide a typed interface to list, get, stop, and delete tasks.
+ */
+import { createApiClient } from "./index.js";
+/**
+ * Lists tasks from the backend with optional filtering.
+ *
+ * @param options - Optional filtering and pagination options.
+ * @param client - Optional ApiClient instance. If not provided, one will be created.
+ * @returns A promise resolving to the list of tasks with pagination info.
+ *
+ * @example
+ * ```typescript
+ * // List all tasks
+ * const result = await listTasks();
+ * console.log(`Found ${result.total} tasks`);
+ *
+ * // List tasks for a specific project
+ * const result = await listTasks({ repository: "owner/repo" });
+ *
+ * // List tasks with a specific status
+ * const result = await listTasks({ status: "completed" });
+ * ```
+ */
+export async function listTasks(options = {}, client) {
+    const apiClient = client ?? (await createApiClient());
+    const params = {};
+    if (options.status !== undefined) {
+        params.status = options.status;
+    }
+    if (options.repository !== undefined) {
+        params.repository = options.repository;
+    }
+    if (options.limit !== undefined) {
+        params.limit = String(options.limit);
+    }
+    if (options.offset !== undefined) {
+        params.offset = String(options.offset);
+    }
+    if (options.search !== undefined) {
+        params.search = options.search;
+    }
+    const response = await apiClient.get("/api/tasks", {
+        params,
+    });
+    return response.data;
+}
+/**
+ * Stops a running task by cancelling it.
+ *
+ * This function sends a cancellation request to the backend to stop
+ * a task that is currently in progress.
+ *
+ * @param taskId - The unique identifier of the task to stop.
+ * @param client - Optional ApiClient instance. If not provided, one will be created.
+ * @returns A promise resolving to the stop response.
+ *
+ * @example
+ * ```typescript
+ * // Stop a running task
+ * const result = await stopTask("task-abc123");
+ * if (result.success) {
+ *   console.log("Task stopped successfully");
+ * }
+ * ```
+ */
+export async function stopTask(taskId, client) {
+    const apiClient = client ?? (await createApiClient());
+    const endpoint = `/api/task/${encodeURIComponent(taskId)}/cancel`;
+    const response = await apiClient.post(endpoint);
+    return response.data;
+}
+/**
+ * Deletes a task from the system.
+ *
+ * This function removes a task and its associated data from the backend.
+ * By default, it will not delete tasks that are in an active state.
+ * Use the force option to override this check.
+ *
+ * @param taskId - The unique identifier of the task to delete.
+ * @param force - If true, force deletion even for active tasks.
+ * @param client - Optional ApiClient instance. If not provided, one will be created.
+ * @returns A promise that resolves when the task is deleted.
+ *
+ * @example
+ * ```typescript
+ * // Delete a completed task
+ * await deleteTask("task-abc123");
+ *
+ * // Force delete an active task
+ * await deleteTask("task-abc123", true);
+ * ```
+ */
+export async function deleteTask(taskId, force = false, client) {
+    const apiClient = client ?? (await createApiClient());
+    const endpoint = `/api/task/${encodeURIComponent(taskId)}`;
+    const params = {};
+    if (force) {
+        params.force = "true";
+    }
+    await apiClient.delete(endpoint, { params });
+}
+/**
+ * Queues a revert task to revert changes from a specific commit in a PR.
+ *
+ * This function sends a revert request to the backend to queue a background
+ * job that will revert the specified commit from the PR.
+ *
+ * @param owner - The repository owner.
+ * @param repo - The repository name.
+ * @param prNumber - The PR number.
+ * @param commitHash - The commit hash to revert.
+ * @param commentId - The comment ID that triggered the revert.
+ * @param client - Optional ApiClient instance. If not provided, one will be created.
+ * @returns A promise resolving to the revert task response.
+ *
+ * @example
+ * ```typescript
+ * // Revert a commit from a PR
+ * const result = await revertTask("owner", "repo", 42, "abc1234", 12345);
+ * if (result.success) {
+ *   console.log(`Revert task queued: ${result.jobId}`);
+ * }
+ * ```
+ */
+export async function revertTask(owner, repo, prNumber, commitHash, commentId, client) {
+    const apiClient = client ?? (await createApiClient());
+    const body = {
+        owner,
+        repo,
+        pr: String(prNumber),
+        commit: commitHash,
+        commentId: String(commentId),
+    };
+    const response = await apiClient.post("/api/tasks/revert", { body });
+    return response.data;
+}