propr-cli 0.8.3

package/dist/api/implement.js

@@ -0,0 +1,147 @@
+/**
+ * Implementation API
+ *
+ * Functions for interacting with the ProPR backend implementation endpoints.
+ * These functions provide a typed interface to trigger issue implementations
+ * and poll task status.
+ */
+import { createApiClient } from "./index.js";
+/**
+ * Triggers implementation for a specific issue/task.
+ *
+ * This function calls the backend endpoint to start implementing an issue
+ * that was created as part of a plan. The backend identifies issues using
+ * the combination of draft ID and issue number.
+ *
+ * @param draftId - The unique identifier of the plan draft containing the issue.
+ * @param issueNumber - The GitHub issue number to implement.
+ * @param options - Optional configuration for the implementation.
+ * @param client - Optional ApiClient instance. If not provided, one will be created.
+ * @returns A promise resolving to the implementation response containing task ID for polling.
+ *
+ * @example
+ * ```typescript
+ * // Implement a single issue with default settings
+ * const result = await implementIssue("draft-123", 1);
+ * console.log(result.message);
+ * if (result.taskId) {
+ *   // Poll for status using the task ID
+ *   const status = await getTaskStatus(result.taskId);
+ * }
+ *
+ * // Implement with a specific model
+ * const result = await implementIssue("draft-123", 1, {
+ *   agent_alias: "claude-code",
+ *   model_name: "claude-sonnet-4-20250514"
+ * });
+ *
+ * // Implement with Epic PR and auto-merge
+ * const result = await implementIssue("draft-123", 1, {
+ *   useEpic: true,
+ *   autoMerge: true
+ * });
+ * ```
+ */
+export async function implementIssue(draftId, issueNumber, options = {}, client) {
+    const apiClient = client ?? (await createApiClient());
+    const body = {};
+    if (options.agent_alias !== undefined) {
+        body.agent_alias = options.agent_alias;
+    }
+    if (options.model_name !== undefined) {
+        body.model_name = options.model_name;
+    }
+    if (options.models !== undefined) {
+        body.models = options.models;
+    }
+    if (options.useEpic !== undefined) {
+        body.useEpic = options.useEpic;
+    }
+    if (options.autoMerge !== undefined) {
+        body.autoMerge = options.autoMerge;
+    }
+    const endpoint = `/api/planner/drafts/${encodeURIComponent(draftId)}/issues/${encodeURIComponent(String(issueNumber))}/implement`;
+    const response = await apiClient.post(endpoint, {
+        body,
+    });
+    return response.data;
+}
+/**
+ * Fetches the status of an executing background task.
+ *
+ * This function retrieves the current state and history of a task,
+ * allowing the CLI to poll for progress and completion.
+ *
+ * @param taskId - The unique identifier of the task to check.
+ * @param client - Optional ApiClient instance. If not provided, one will be created.
+ * @returns A promise resolving to the parsed task status with convenience fields.
+ *
+ * @example
+ * ```typescript
+ * // Get the status of a task
+ * const status = await getTaskStatus("task-abc123");
+ * console.log(`Current state: ${status.currentState}`);
+ *
+ * if (status.isCompleted) {
+ *   console.log("Task completed successfully!");
+ *   if (status.prNumber) {
+ *     console.log(`PR created: #${status.prNumber}`);
+ *   }
+ * } else if (status.isFailed) {
+ *   console.log(`Task failed: ${status.failureReason}`);
+ * } else if (status.isInProgress) {
+ *   console.log("Task is still running...");
+ * }
+ * ```
+ */
+export async function getTaskStatus(taskId, client) {
+    const apiClient = client ?? (await createApiClient());
+    const endpoint = `/api/task/${encodeURIComponent(taskId)}/history`;
+    const response = await apiClient.get(endpoint);
+    return parseTaskStatus(response.data);
+}
+/**
+ * Parses the raw task status response into a more convenient format.
+ *
+ * @param response - The raw task status response from the API.
+ * @returns A parsed TaskStatus with convenience fields.
+ */
+function parseTaskStatus(response) {
+    const { taskId, history, taskInfo } = response;
+    // Get the latest state from history
+    const latestEntry = history.length > 0 ? history[history.length - 1] : null;
+    const currentState = latestEntry?.state?.toLowerCase() || "pending";
+    // Determine status flags
+    const completedStates = ["completed", "failed", "cancelled"];
+    const inProgressStates = ["pending", "queued", "processing", "claude_execution", "post_processing"];
+    const isCompleted = currentState === "completed";
+    const isFailed = currentState === "failed" || currentState === "cancelled";
+    const isInProgress = !completedStates.includes(currentState) && inProgressStates.includes(currentState);
+    // Extract failure reason
+    let failureReason;
+    if (isFailed) {
+        failureReason = latestEntry?.reason || latestEntry?.message || latestEntry?.metadata?.error;
+    }
+    // Extract PR information from history
+    let prNumber;
+    let prUrl;
+    for (const entry of history) {
+        if (entry.metadata?.pullRequest) {
+            prNumber = entry.metadata.pullRequest.number;
+            prUrl = entry.metadata.pullRequest.url;
+            break;
+        }
+    }
+    return {
+        taskId,
+        currentState: currentState,
+        isInProgress,
+        isCompleted,
+        isFailed,
+        failureReason,
+        history,
+        taskInfo,
+        prNumber,
+        prUrl,
+    };
+}

package/dist/api/index.js

@@ -0,0 +1,26 @@
+/**
+ * CLI API Module
+ *
+ * Exports the API client and related types for communicating
+ * with the ProPR backend REST API.
+ */
+export { ApiClient, createApiClient, createApiClientWithConfig, } from "./client.js";
+export { ApiError, UnauthorizedError, ForbiddenError, NotFoundError, BadRequestError, InternalServerError, NetworkError, TimeoutError, createApiError, } from "./errors.js";
+// Plan Management API
+export { listPlans, createPlan, getPlan, deletePlan, abortPlan, listPlanIssues, generatePlan, finalizePlan, } from "./plans.js";
+// Implementation API
+export { implementIssue, getTaskStatus, } from "./implement.js";
+// Tasks API
+export { listTasks, stopTask, deleteTask, revertTask, } from "./tasks.js";
+// Repository Configuration API
+export { getRepos, addRepo, updateRepo, removeRepo, triggerIndexing, getIndexingStatus, reposApi, } from "./repos.js";
+// Agents Configuration API
+export { listAgents, addAgent, deleteAgent, } from "./agents.js";
+// System Settings API
+export { getSettings, updateSettings, updateSetting, isValidSettingKey, parseSettingValue, settingsApi, VALID_SETTING_KEYS, } from "./settings.js";
+// LLM Logs API
+export { listLlmLogs, } from "./logs.js";
+// Repository To-Dos API
+export { listTodos, getTodo, createTodo, updateTodo, deleteTodo, listCategories, createCategory, updateCategory, deleteCategory, reorderTodos, reorderCategories, } from "./todos.js";
+// System Status API
+export { getSystemStatus, getQueueStats, } from "./system.js";

package/dist/api/logs.js

@@ -0,0 +1,59 @@
+/**
+ * LLM Logs API
+ *
+ * Functions for interacting with the ProPR backend LLM logs endpoints.
+ * These functions provide a typed interface to list and filter LLM execution logs.
+ */
+import { createApiClient } from "./index.js";
+/**
+ * Lists LLM logs 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 logs with pagination info.
+ *
+ * @example
+ * ```typescript
+ * // List all logs
+ * const result = await listLlmLogs();
+ * console.log(`Found ${result.pagination.total} logs`);
+ *
+ * // List logs for a specific model
+ * const result = await listLlmLogs({ model: "claude-3-opus" });
+ *
+ * // List logs with pagination
+ * const result = await listLlmLogs({ page: 2, limit: 20 });
+ * ```
+ */
+export async function listLlmLogs(options = {}, client) {
+    const apiClient = client ?? (await createApiClient());
+    const params = {};
+    if (options.page !== undefined) {
+        params.page = String(options.page);
+    }
+    if (options.limit !== undefined) {
+        params.limit = String(options.limit);
+    }
+    if (options.executionType !== undefined) {
+        params.execution_type = options.executionType;
+    }
+    if (options.model !== undefined) {
+        params.model = options.model;
+    }
+    if (options.success !== undefined) {
+        params.success = options.success ? "true" : "false";
+    }
+    if (options.draftId !== undefined) {
+        params.draft_id = options.draftId;
+    }
+    if (options.agentAlias !== undefined) {
+        params.agent_alias = options.agentAlias;
+    }
+    if (options.workType !== undefined) {
+        params.work_type = options.workType;
+    }
+    const response = await apiClient.get("/api/llm-logs", {
+        params,
+    });
+    return response.data;
+}

package/dist/api/plans.js

@@ -0,0 +1,160 @@
+/**
+ * Plan Management API
+ *
+ * Functions for interacting with the ProPR backend plan endpoints.
+ * These functions provide a typed interface to list, create, and fetch plans.
+ */
+import { createApiClient } from "./index.js";
+/**
+ * Fetches plans for a specific repository.
+ *
+ * @param project - The repository identifier (e.g., "owner/repo").
+ * @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 plans with pagination info.
+ *
+ * @example
+ * ```typescript
+ * const result = await listPlans("owner/repo");
+ * console.log(`Found ${result.total} plans`);
+ * for (const plan of result.drafts) {
+ *   console.log(`- ${plan.name} (${plan.status})`);
+ * }
+ * ```
+ */
+export async function listPlans(project, options = {}, client) {
+    const apiClient = client ?? (await createApiClient());
+    const params = {
+        repository: project,
+        page: options.page,
+        limit: options.limit,
+        search: options.search,
+        status: options.status,
+        excludeStatuses: options.excludeStatuses,
+    };
+    const response = await apiClient.get("/api/planner/drafts", {
+        params,
+    });
+    return response.data;
+}
+/**
+ * Submits a new plan generation request.
+ *
+ * @param project - The repository identifier (e.g., "owner/repo").
+ * @param prompt - The initial prompt describing the plan.
+ * @param options - Optional additional options for plan creation.
+ * @param client - Optional ApiClient instance. If not provided, one will be created.
+ * @returns A promise resolving to the created plan.
+ *
+ * @example
+ * ```typescript
+ * const plan = await createPlan("owner/repo", "Add user authentication feature");
+ * console.log(`Created plan: ${plan.draft_id}`);
+ * ```
+ */
+export async function createPlan(project, prompt, options = {}, client) {
+    const apiClient = client ?? (await createApiClient());
+    const body = {
+        repository: project,
+        prompt,
+        ...options,
+    };
+    const response = await apiClient.post("/api/planner/drafts", {
+        body,
+    });
+    return response.data;
+}
+/**
+ * Fetches details of a specific plan.
+ *
+ * @param planId - The unique identifier of the plan (draft_id).
+ * @param client - Optional ApiClient instance. If not provided, one will be created.
+ * @returns A promise resolving to the plan details.
+ *
+ * @example
+ * ```typescript
+ * const plan = await getPlan("abc123-uuid");
+ * console.log(`Plan status: ${plan.status}`);
+ * console.log(`Plan items: ${plan.plan_json.length}`);
+ * ```
+ */
+export async function getPlan(planId, client) {
+    const apiClient = client ?? (await createApiClient());
+    const response = await apiClient.get(`/api/planner/drafts/${encodeURIComponent(planId)}`);
+    return response.data;
+}
+/**
+ * Deletes a specific plan.
+ *
+ * @param planId - The unique identifier of the plan (draft_id).
+ * @param client - Optional ApiClient instance. If not provided, one will be created.
+ * @returns A promise that resolves when the plan is deleted.
+ *
+ * @example
+ * ```typescript
+ * await deletePlan("abc123-uuid");
+ * console.log("Plan deleted successfully");
+ * ```
+ */
+export async function deletePlan(planId, client) {
+    const apiClient = client ?? (await createApiClient());
+    await apiClient.delete(`/api/planner/drafts/${encodeURIComponent(planId)}`);
+}
+/**
+ * Aborts an ongoing plan generation.
+ *
+ * @param planId - The unique identifier of the plan (draft_id).
+ * @param client - Optional ApiClient instance. If not provided, one will be created.
+ * @returns A promise resolving to the abort response.
+ *
+ * @example
+ * ```typescript
+ * const result = await abortPlan("abc123-uuid");
+ * console.log(result.message); // "Generation aborted"
+ * ```
+ */
+export async function abortPlan(planId, client) {
+    const apiClient = client ?? (await createApiClient());
+    const response = await apiClient.post("/api/planner/abort", {
+        body: { draftId: planId },
+    });
+    return response.data;
+}
+/**
+ * Finalizes a plan by creating GitHub issues from its plan items.
+ *
+ * @param draftId - The unique identifier of the plan draft.
+ * @param client - Optional ApiClient instance. If not provided, one will be created.
+ * @returns A promise resolving to the finalization response.
+ */
+export async function finalizePlan(draftId, client) {
+    const apiClient = client ?? (await createApiClient());
+    const response = await apiClient.post("/api/planner/finalize", { body: { draftId } });
+    return response.data;
+}
+/**
+ * Triggers plan generation for an existing draft.
+ *
+ * @param draftId - The unique identifier of the plan draft.
+ * @param options - Optional generation configuration.
+ * @param client - Optional ApiClient instance. If not provided, one will be created.
+ * @returns A promise resolving to the generation response.
+ */
+export async function generatePlan(draftId, options = {}, client) {
+    const apiClient = client ?? (await createApiClient());
+    const body = { draftId, ...options };
+    const response = await apiClient.post("/api/planner/generate", { body });
+    return response.data;
+}
+/**
+ * Lists issues associated with a plan.
+ *
+ * @param planId - The unique identifier of the plan (draft_id).
+ * @param client - Optional ApiClient instance. If not provided, one will be created.
+ * @returns A promise resolving to the list of plan issues.
+ */
+export async function listPlanIssues(planId, client) {
+    const apiClient = client ?? (await createApiClient());
+    const response = await apiClient.get(`/api/planner/drafts/${encodeURIComponent(planId)}/issues`);
+    return response.data;
+}

package/dist/api/relay.js

@@ -0,0 +1,73 @@
+/**
+ * GitHub token relay API (auth path 2).
+ *
+ * These call the vendor-run relay's enrollment endpoints (propr-routing's
+ * /v1/relay-tokens routes), authenticated by the user's GitHub token (the same
+ * token `propr login` stores). They are distinct from the ProPR backend API —
+ * the relay is a separate service, and the daemon later uses the issued relay
+ * token against /v1/installation-token.
+ */
+const FETCH_TIMEOUT_MS = 15_000;
+function baseUrl(options) {
+    return options.baseUrl.replace(/\/+$/, "");
+}
+async function relayRequest(options, path, method, body, init) {
+    let response;
+    try {
+        const headers = {
+            authorization: `Bearer ${options.githubToken}`,
+            accept: "application/json",
+        };
+        if (body !== undefined) {
+            headers["content-type"] = "application/json";
+        }
+        response = await fetch(`${baseUrl(options)}${path}`, {
+            method,
+            headers,
+            body: body === undefined ? undefined : JSON.stringify(body),
+            signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+        });
+    }
+    catch (error) {
+        throw new Error(`Cannot reach the relay at ${options.baseUrl}: ${error.message}`);
+    }
+    if (!response.ok) {
+        let code = "";
+        try {
+            const parsed = (await response.json());
+            code = parsed?.error?.code ?? "";
+        }
+        catch {
+            /* non-JSON error body */
+        }
+        if (response.status === 401) {
+            throw new Error("The relay rejected your GitHub token. Run `propr login` to refresh it.");
+        }
+        if (response.status === 403) {
+            throw new Error("You are not authorized for this installation. Confirm the shared GitHub App is installed and you have access to it.");
+        }
+        if (response.status === 404 && init?.notFoundMessage) {
+            throw new Error(init.notFoundMessage);
+        }
+        throw new Error(`Relay request failed (HTTP ${response.status}${code ? ` ${code}` : ""}).`);
+    }
+    try {
+        return (await response.json());
+    }
+    catch {
+        throw new Error("The relay returned a malformed JSON response.");
+    }
+}
+export function enrollRelayToken(options, params) {
+    return relayRequest(options, "/relay-tokens", "POST", {
+        installation_id: params.installationId,
+        label: params.label ?? null,
+    });
+}
+export function listRelayTokens(options, installationId) {
+    const query = encodeURIComponent(String(installationId));
+    return relayRequest(options, `/relay-tokens?installation_id=${query}`, "GET");
+}
+export function revokeRelayToken(options, params) {
+    return relayRequest(options, "/relay-tokens/revoke", "POST", { installation_id: params.installationId, token_id: params.tokenId }, { notFoundMessage: "Relay token not found (already revoked or wrong token id)." });
+}